Deploying to gh-pages from @ 598682c 🚀

Author: github-merge-queue[bot]

api/src/rustc_codegen_spirv/builder/builder_methods.rs.html

@@ -3641,7 +3641,111 @@
 <a href="#3640" id="3640">3640</a>
 <a href="#3641" id="3641">3641</a>
 <a href="#3642" id="3642">3642</a>
-<a href="#3643" id="3643">3643</a></pre></div><pre class="rust"><code><span class="comment">// HACK(eddyb) avoids rewriting all of the imports (see `lib.rs` and `build.rs`).
+<a href="#3643" id="3643">3643</a>
+<a href="#3644" id="3644">3644</a>
+<a href="#3645" id="3645">3645</a>
+<a href="#3646" id="3646">3646</a>
+<a href="#3647" id="3647">3647</a>
+<a href="#3648" id="3648">3648</a>
+<a href="#3649" id="3649">3649</a>
+<a href="#3650" id="3650">3650</a>
+<a href="#3651" id="3651">3651</a>
+<a href="#3652" id="3652">3652</a>
+<a href="#3653" id="3653">3653</a>
+<a href="#3654" id="3654">3654</a>
+<a href="#3655" id="3655">3655</a>
+<a href="#3656" id="3656">3656</a>
+<a href="#3657" id="3657">3657</a>
+<a href="#3658" id="3658">3658</a>
+<a href="#3659" id="3659">3659</a>
+<a href="#3660" id="3660">3660</a>
+<a href="#3661" id="3661">3661</a>
+<a href="#3662" id="3662">3662</a>
+<a href="#3663" id="3663">3663</a>
+<a href="#3664" id="3664">3664</a>
+<a href="#3665" id="3665">3665</a>
+<a href="#3666" id="3666">3666</a>
+<a href="#3667" id="3667">3667</a>
+<a href="#3668" id="3668">3668</a>
+<a href="#3669" id="3669">3669</a>
+<a href="#3670" id="3670">3670</a>
+<a href="#3671" id="3671">3671</a>
+<a href="#3672" id="3672">3672</a>
+<a href="#3673" id="3673">3673</a>
+<a href="#3674" id="3674">3674</a>
+<a href="#3675" id="3675">3675</a>
+<a href="#3676" id="3676">3676</a>
+<a href="#3677" id="3677">3677</a>
+<a href="#3678" id="3678">3678</a>
+<a href="#3679" id="3679">3679</a>
+<a href="#3680" id="3680">3680</a>
+<a href="#3681" id="3681">3681</a>
+<a href="#3682" id="3682">3682</a>
+<a href="#3683" id="3683">3683</a>
+<a href="#3684" id="3684">3684</a>
+<a href="#3685" id="3685">3685</a>
+<a href="#3686" id="3686">3686</a>
+<a href="#3687" id="3687">3687</a>
+<a href="#3688" id="3688">3688</a>
+<a href="#3689" id="3689">3689</a>
+<a href="#3690" id="3690">3690</a>
+<a href="#3691" id="3691">3691</a>
+<a href="#3692" id="3692">3692</a>
+<a href="#3693" id="3693">3693</a>
+<a href="#3694" id="3694">3694</a>
+<a href="#3695" id="3695">3695</a>
+<a href="#3696" id="3696">3696</a>
+<a href="#3697" id="3697">3697</a>
+<a href="#3698" id="3698">3698</a>
+<a href="#3699" id="3699">3699</a>
+<a href="#3700" id="3700">3700</a>
+<a href="#3701" id="3701">3701</a>
+<a href="#3702" id="3702">3702</a>
+<a href="#3703" id="3703">3703</a>
+<a href="#3704" id="3704">3704</a>
+<a href="#3705" id="3705">3705</a>
+<a href="#3706" id="3706">3706</a>
+<a href="#3707" id="3707">3707</a>
+<a href="#3708" id="3708">3708</a>
+<a href="#3709" id="3709">3709</a>
+<a href="#3710" id="3710">3710</a>
+<a href="#3711" id="3711">3711</a>
+<a href="#3712" id="3712">3712</a>
+<a href="#3713" id="3713">3713</a>
+<a href="#3714" id="3714">3714</a>
+<a href="#3715" id="3715">3715</a>
+<a href="#3716" id="3716">3716</a>
+<a href="#3717" id="3717">3717</a>
+<a href="#3718" id="3718">3718</a>
+<a href="#3719" id="3719">3719</a>
+<a href="#3720" id="3720">3720</a>
+<a href="#3721" id="3721">3721</a>
+<a href="#3722" id="3722">3722</a>
+<a href="#3723" id="3723">3723</a>
+<a href="#3724" id="3724">3724</a>
+<a href="#3725" id="3725">3725</a>
+<a href="#3726" id="3726">3726</a>
+<a href="#3727" id="3727">3727</a>
+<a href="#3728" id="3728">3728</a>
+<a href="#3729" id="3729">3729</a>
+<a href="#3730" id="3730">3730</a>
+<a href="#3731" id="3731">3731</a>
+<a href="#3732" id="3732">3732</a>
+<a href="#3733" id="3733">3733</a>
+<a href="#3734" id="3734">3734</a>
+<a href="#3735" id="3735">3735</a>
+<a href="#3736" id="3736">3736</a>
+<a href="#3737" id="3737">3737</a>
+<a href="#3738" id="3738">3738</a>
+<a href="#3739" id="3739">3739</a>
+<a href="#3740" id="3740">3740</a>
+<a href="#3741" id="3741">3741</a>
+<a href="#3742" id="3742">3742</a>
+<a href="#3743" id="3743">3743</a>
+<a href="#3744" id="3744">3744</a>
+<a href="#3745" id="3745">3745</a>
+<a href="#3746" id="3746">3746</a>
+<a href="#3747" id="3747">3747</a></pre></div><pre class="rust"><code><span class="comment">// HACK(eddyb) avoids rewriting all of the imports (see `lib.rs` and `build.rs`).
 </span><span class="kw">use </span><span class="kw">crate</span>::maybe_pqp_cg_ssa <span class="kw">as </span>rustc_codegen_ssa;
 
 <span class="kw">use </span><span class="kw">super</span>::Builder;
@@ -5676,7 +5780,32 @@
         <span class="kw">if </span>val.ty == dest_ty {
             val
         } <span class="kw">else </span>{
-            <span class="self">self</span>.emit()
+            <span class="comment">// If casting a constant, directly create a constant of the target type.
+            // This avoids creating intermediate types that might require additional
+            // capabilities. For example, casting a f16 constant to f32 will directly
+            // create a f32 constant, avoiding the need for Float16 capability if it is
+            // not used elsewhere.
+            </span><span class="kw">if let </span><span class="prelude-val">Some</span>(const_val) = <span class="self">self</span>.builder.lookup_const_scalar(val) {
+                <span class="kw">if let </span>(SpirvType::Float(src_width), SpirvType::Float(dst_width)) =
+                    (<span class="self">self</span>.lookup_type(val.ty), <span class="self">self</span>.lookup_type(dest_ty))
+                {
+                    <span class="kw">if </span>src_width &lt; dst_width {
+                        <span class="comment">// Convert the bit representation to the actual float value
+                        </span><span class="kw">let </span>float_val = <span class="kw">match </span>src_width {
+                            <span class="number">32 </span>=&gt; <span class="prelude-val">Some</span>(f32::from_bits(const_val <span class="kw">as </span>u32) <span class="kw">as </span>f64),
+                            <span class="number">64 </span>=&gt; <span class="prelude-val">Some</span>(f64::from_bits(const_val <span class="kw">as </span>u64)),
+                            <span class="kw">_ </span>=&gt; <span class="prelude-val">None</span>,
+                        };
+
+                        <span class="kw">if let </span><span class="prelude-val">Some</span>(val) = float_val {
+                            <span class="kw">return </span><span class="self">self</span>.constant_float(dest_ty, val);
+                        }
+                    }
+                }
+            }
+
+            <span class="comment">// Regular conversion
+            </span><span class="self">self</span>.emit()
                 .f_convert(dest_ty, <span class="prelude-val">None</span>, val.def(<span class="self">self</span>))
                 .unwrap()
                 .with_type(dest_ty)
@@ -5841,6 +5970,46 @@
             <span class="comment">// I guess?
             </span><span class="kw">return </span>val;
         }
+
+        <span class="comment">// If casting a constant, directly create a constant of the target type. This
+        // avoids creating intermediate types that might require additional
+        // capabilities. For example, casting a u8 constant to u32 will directly create
+        // a u32 constant, avoiding the need for Int8 capability if it is not used
+        // elsewhere.
+        </span><span class="kw">if let </span><span class="prelude-val">Some</span>(const_val) = <span class="self">self</span>.builder.lookup_const_scalar(val) {
+            <span class="kw">let </span>src_ty = <span class="self">self</span>.lookup_type(val.ty);
+            <span class="kw">let </span>dst_ty_spv = <span class="self">self</span>.lookup_type(dest_ty);
+
+            <span class="comment">// Try to optimize the constant cast
+            </span><span class="kw">let </span>optimized_result = <span class="kw">match </span>(src_ty, dst_ty_spv) {
+                <span class="comment">// Integer to integer cast
+                </span>(SpirvType::Integer(src_width, <span class="kw">_</span>), SpirvType::Integer(dst_width, <span class="kw">_</span>)) =&gt; {
+                    <span class="comment">// Only optimize if we're widening. This avoids creating the source
+                    // type when it's safe to do so. For narrowing casts (e.g., u32 as
+                    // u8), we need the proper truncation behavior that the regular cast
+                    // provides.
+                    </span><span class="kw">if </span>src_width &lt; dst_width {
+                        <span class="prelude-val">Some</span>(<span class="self">self</span>.constant_int(dest_ty, const_val))
+                    } <span class="kw">else </span>{
+                        <span class="prelude-val">None
+                    </span>}
+                }
+                <span class="comment">// Bool to integer cast - const_val will be 0 or 1
+                </span>(SpirvType::Bool, SpirvType::Integer(<span class="kw">_</span>, <span class="kw">_</span>)) =&gt; {
+                    <span class="prelude-val">Some</span>(<span class="self">self</span>.constant_int(dest_ty, const_val))
+                }
+                <span class="comment">// Integer to bool cast - compare with zero
+                </span>(SpirvType::Integer(<span class="kw">_</span>, <span class="kw">_</span>), SpirvType::Bool) =&gt; {
+                    <span class="prelude-val">Some</span>(<span class="self">self</span>.constant_bool(<span class="self">self</span>.span(), const_val != <span class="number">0</span>))
+                }
+                <span class="kw">_ </span>=&gt; <span class="prelude-val">None</span>,
+            };
+
+            <span class="kw">if let </span><span class="prelude-val">Some</span>(result) = optimized_result {
+                <span class="kw">return </span>result;
+            }
+        }
+
         <span class="kw">match </span>(<span class="self">self</span>.lookup_type(val.ty), <span class="self">self</span>.lookup_type(dest_ty)) {
             <span class="comment">// sign change
             </span>(
@@ -6771,6 +6940,8 @@
             .and_then(|def_id| <span class="self">self</span>.buffer_store_intrinsics.borrow().get(<span class="kw-2">&amp;</span>def_id).copied());
         <span class="kw">let </span>is_panic_entry_point = instance_def_id
             .is_some_and(|def_id| <span class="self">self</span>.panic_entry_points.borrow().contains(<span class="kw-2">&amp;</span>def_id));
+        <span class="kw">let </span>from_trait_impl =
+            instance_def_id.and_then(|def_id| <span class="self">self</span>.from_trait_impls.borrow().get(<span class="kw-2">&amp;</span>def_id).copied());
 
         <span class="kw">if let </span><span class="prelude-val">Some</span>(libm_intrinsic) = libm_intrinsic {
             <span class="kw">let </span>result = <span class="self">self</span>.call_libm_intrinsic(libm_intrinsic, result_type, args);
@@ -6782,8 +6953,10 @@
                     <span class="self">self</span>.debug_type(result.ty),
                 );
             }
-            result
-        } <span class="kw">else if </span>is_panic_entry_point {
+            <span class="kw">return </span>result;
+        }
+
+        <span class="kw">if </span>is_panic_entry_point {
             <span class="comment">// HACK(eddyb) Rust 2021 `panic!` always uses `format_args!`, even
             // in the simple case that used to pass a `&amp;str` constant, which
             // would not remain reachable in the SPIR-V - but `format_args!` is
@@ -7256,24 +7429,59 @@
             <span class="comment">// HACK(eddyb) redirect any possible panic call to an abort, to avoid
             // needing to materialize `&amp;core::panic::Location` or `format_args!`.
             </span><span class="self">self</span>.abort_with_kind_and_message_debug_printf(<span class="string">"panic"</span>, message, debug_printf_args);
-            <span class="self">self</span>.undef(result_type)
-        } <span class="kw">else if let </span><span class="prelude-val">Some</span>(mode) = buffer_load_intrinsic {
-            <span class="self">self</span>.codegen_buffer_load_intrinsic(result_type, args, mode)
-        } <span class="kw">else if let </span><span class="prelude-val">Some</span>(mode) = buffer_store_intrinsic {
+            <span class="kw">return </span><span class="self">self</span>.undef(result_type);
+        }
+
+        <span class="kw">if let </span><span class="prelude-val">Some</span>(mode) = buffer_load_intrinsic {
+            <span class="kw">return </span><span class="self">self</span>.codegen_buffer_load_intrinsic(result_type, args, mode);
+        }
+
+        <span class="kw">if let </span><span class="prelude-val">Some</span>(mode) = buffer_store_intrinsic {
             <span class="self">self</span>.codegen_buffer_store_intrinsic(args, mode);
 
             <span class="kw">let </span>void_ty = SpirvType::Void.def(rustc_span::DUMMY_SP, <span class="self">self</span>);
-            SpirvValue {
+            <span class="kw">return </span>SpirvValue {
                 kind: SpirvValueKind::IllegalTypeUsed(void_ty),
                 ty: void_ty,
+            };
+        }
+
+        <span class="kw">if let </span><span class="prelude-val">Some</span>((source_ty, target_ty)) = from_trait_impl {
+            <span class="comment">// Optimize From::from calls with constant arguments to avoid creating intermediate types.
+            // Since From is only implemented for safe conversions (widening conversions that preserve
+            // the numeric value), we can directly create a constant of the target type for primitive
+            // numeric types.
+            </span><span class="kw">if let </span>[arg] = args {
+                <span class="kw">if let </span><span class="prelude-val">Some</span>(const_val) = <span class="self">self</span>.builder.lookup_const_scalar(<span class="kw-2">*</span>arg) {
+                    <span class="kw">use </span>rustc_middle::ty::FloatTy;
+                    <span class="kw">let </span>optimized_result = <span class="kw">match </span>(source_ty.kind(), target_ty.kind()) {
+                        <span class="comment">// Integer widening conversions
+                        </span>(ty::Uint(<span class="kw">_</span>), ty::Uint(<span class="kw">_</span>)) | (ty::Int(<span class="kw">_</span>), ty::Int(<span class="kw">_</span>)) =&gt; {
+                            <span class="prelude-val">Some</span>(<span class="self">self</span>.constant_int(result_type, const_val))
+                        }
+                        <span class="comment">// Float widening conversions
+                        // TODO(@LegNeato): Handle more float types
+                        </span>(ty::Float(FloatTy::F32), ty::Float(FloatTy::F64)) =&gt; {
+                            <span class="kw">let </span>float_val = f32::from_bits(const_val <span class="kw">as </span>u32) <span class="kw">as </span>f64;
+                            <span class="prelude-val">Some</span>(<span class="self">self</span>.constant_float(result_type, float_val))
+                        }
+                        <span class="comment">// No optimization for narrowing conversions or unsupported types
+                        </span><span class="kw">_ </span>=&gt; <span class="prelude-val">None</span>,
+                    };
+
+                    <span class="kw">if let </span><span class="prelude-val">Some</span>(result) = optimized_result {
+                        <span class="kw">return </span>result;
+                    }
+                }
             }
-        } <span class="kw">else </span>{
-            <span class="kw">let </span>args = args.iter().map(|arg| arg.def(<span class="self">self</span>)).collect::&lt;Vec&lt;<span class="kw">_</span>&gt;&gt;();
-            <span class="self">self</span>.emit()
-                .function_call(result_type, <span class="prelude-val">None</span>, callee_val, args)
-                .unwrap()
-                .with_type(result_type)
         }
+
+        <span class="comment">// Default: emit a regular function call
+        </span><span class="kw">let </span>args = args.iter().map(|arg| arg.def(<span class="self">self</span>)).collect::&lt;Vec&lt;<span class="kw">_</span>&gt;&gt;();
+        <span class="self">self</span>.emit()
+            .function_call(result_type, <span class="prelude-val">None</span>, callee_val, args)
+            .unwrap()
+            .with_type(result_type)
     }
 
     <span class="kw">fn </span>zext(<span class="kw-2">&amp;mut </span><span class="self">self</span>, val: <span class="self">Self</span>::Value, dest_ty: <span class="self">Self</span>::Type) -&gt; <span class="self">Self</span>::Value {

api/src/rustc_codegen_spirv/codegen_cx/declare.rs.html

@@ -373,7 +373,31 @@
 <a href="#372" id="372">372</a>
 <a href="#373" id="373">373</a>
 <a href="#374" id="374">374</a>
-<a href="#375" id="375">375</a></pre></div><pre class="rust"><code><span class="comment">// HACK(eddyb) avoids rewriting all of the imports (see `lib.rs` and `build.rs`).
+<a href="#375" id="375">375</a>
+<a href="#376" id="376">376</a>
+<a href="#377" id="377">377</a>
+<a href="#378" id="378">378</a>
+<a href="#379" id="379">379</a>
+<a href="#380" id="380">380</a>
+<a href="#381" id="381">381</a>
+<a href="#382" id="382">382</a>
+<a href="#383" id="383">383</a>
+<a href="#384" id="384">384</a>
+<a href="#385" id="385">385</a>
+<a href="#386" id="386">386</a>
+<a href="#387" id="387">387</a>
+<a href="#388" id="388">388</a>
+<a href="#389" id="389">389</a>
+<a href="#390" id="390">390</a>
+<a href="#391" id="391">391</a>
+<a href="#392" id="392">392</a>
+<a href="#393" id="393">393</a>
+<a href="#394" id="394">394</a>
+<a href="#395" id="395">395</a>
+<a href="#396" id="396">396</a>
+<a href="#397" id="397">397</a>
+<a href="#398" id="398">398</a>
+<a href="#399" id="399">399</a></pre></div><pre class="rust"><code><span class="comment">// HACK(eddyb) avoids rewriting all of the imports (see `lib.rs` and `build.rs`).
 </span><span class="kw">use </span><span class="kw">crate</span>::maybe_pqp_cg_ssa <span class="kw">as </span>rustc_codegen_ssa;
 
 <span class="kw">use </span><span class="kw">super</span>::CodegenCx;
@@ -547,6 +571,30 @@
             }
         }
 
+        <span class="comment">// Check if this is a From trait implementation
+        </span><span class="kw">if let </span><span class="prelude-val">Some</span>(impl_def_id) = <span class="self">self</span>.tcx.impl_of_method(def_id) {
+            <span class="kw">if let </span><span class="prelude-val">Some</span>(trait_ref) = <span class="self">self</span>.tcx.impl_trait_ref(impl_def_id) {
+                <span class="kw">let </span>trait_def_id = trait_ref.skip_binder().def_id;
+
+                <span class="comment">// Check if this is the From trait.
+                </span><span class="kw">let </span>trait_path = <span class="self">self</span>.tcx.def_path_str(trait_def_id);
+                <span class="kw">if </span><span class="macro">matches!</span>(
+                    trait_path.as_str(),
+                    <span class="string">"core::convert::From" </span>| <span class="string">"std::convert::From"
+                </span>) {
+                    <span class="comment">// Extract the source and target types from the trait substitutions
+                    </span><span class="kw">let </span>trait_args = trait_ref.skip_binder().args;
+                    <span class="kw">if let </span>(<span class="prelude-val">Some</span>(target_ty), <span class="prelude-val">Some</span>(source_ty)) =
+                        (trait_args.types().nth(<span class="number">0</span>), trait_args.types().nth(<span class="number">1</span>))
+                    {
+                        <span class="self">self</span>.from_trait_impls
+                            .borrow_mut()
+                            .insert(def_id, (source_ty, target_ty));
+                    }
+                }
+            }
+        }
+
         <span class="kw">if </span>[
             <span class="self">self</span>.tcx.lang_items().panic_fn(),
             <span class="self">self</span>.tcx.lang_items().panic_fmt(),