Skip to content

Commit b23a729

Browse files
github-merge-queue[bot]github-merge-queue[bot]
committed
Deploying to gh-pages from @ 05042d1 🚀
1 parent f6091a6 commit b23a729

File tree

4 files changed

+88
-152
lines changed

4 files changed

+88
-152
lines changed

‎api/src/rustc_codegen_spirv/builder/intrinsics.rs.html

Lines changed: 31 additions & 59 deletions
Original file line numberDiff line numberDiff line change
@@ -624,21 +624,7 @@
624624
<a href="#623" id="623">623</a>
625625
<a href="#624" id="624">624</a>
626626
<a href="#625" id="625">625</a>
627-
<a href="#626" id="626">626</a>
628-
<a href="#627" id="627">627</a>
629-
<a href="#628" id="628">628</a>
630-
<a href="#629" id="629">629</a>
631-
<a href="#630" id="630">630</a>
632-
<a href="#631" id="631">631</a>
633-
<a href="#632" id="632">632</a>
634-
<a href="#633" id="633">633</a>
635-
<a href="#634" id="634">634</a>
636-
<a href="#635" id="635">635</a>
637-
<a href="#636" id="636">636</a>
638-
<a href="#637" id="637">637</a>
639-
<a href="#638" id="638">638</a>
640-
<a href="#639" id="639">639</a>
641-
<a href="#640" id="640">640</a></pre></div><pre class="rust"><code><span class="comment">// HACK(eddyb) avoids rewriting all of the imports (see `lib.rs` and `build.rs`).
627+
<a href="#626" id="626">626</a></pre></div><pre class="rust"><code><span class="comment">// HACK(eddyb) avoids rewriting all of the imports (see `lib.rs` and `build.rs`).
642628
</span><span class="kw">use </span><span class="kw">crate</span>::maybe_pqp_cg_ssa <span class="kw">as </span>rustc_codegen_ssa;
643629

644630
<span class="kw">use </span><span class="kw">super</span>::Builder;
@@ -932,14 +918,10 @@
932918
<span class="kw">let </span>res3 = <span class="self">self</span>.or(res3, res4);
933919
<span class="self">self</span>.or(res1, res3)
934920
}
935-
other =&gt; {
936-
<span class="kw">let </span>undef = <span class="self">self</span>.undef(ret_ty);
937-
<span class="self">self</span>.zombie(
938-
undef.def(<span class="self">self</span>),
939-
<span class="kw-2">&amp;</span><span class="macro">format!</span>(<span class="string">"bswap not implemented for int width {other}"</span>),
940-
);
941-
undef
942-
}
921+
other =&gt; <span class="self">self</span>.undef_zombie(
922+
ret_ty,
923+
<span class="kw-2">&amp;</span><span class="macro">format!</span>(<span class="string">"bswap not implemented for int width {other}"</span>),
924+
),
943925
};
944926

945927
<span class="comment">// Cast back to the original signed type if necessary
@@ -950,11 +932,7 @@
950932
}
951933
}
952934

953-
sym::compare_bytes =&gt; {
954-
<span class="kw">let </span>undef = <span class="self">self</span>.undef(ret_ty);
955-
<span class="self">self</span>.zombie(undef.def(<span class="self">self</span>), <span class="string">"memcmp not implemented"</span>);
956-
undef
957-
}
935+
sym::compare_bytes =&gt; <span class="self">self</span>.undef_zombie(ret_ty, <span class="string">"memcmp not implemented"</span>),
958936

959937
<span class="kw">_ </span>=&gt; {
960938
<span class="comment">// Call the fallback body instead of generating the intrinsic code
@@ -1037,12 +1015,10 @@
10371015
.unwrap()
10381016
}
10391017
<span class="kw">_ </span>=&gt; {
1040-
<span class="kw">let </span>undef = <span class="self">self</span>.undef(ty).def(<span class="self">self</span>);
1041-
<span class="self">self</span>.zombie(
1042-
undef,
1018+
<span class="kw">return </span><span class="self">self</span>.undef_zombie(
1019+
ty,
10431020
<span class="kw-2">&amp;</span><span class="macro">format!</span>(<span class="string">"count_ones() on unsupported {ty:?} bit integer type"</span>),
10441021
);
1045-
undef
10461022
}
10471023
}
10481024
.with_type(u32)
@@ -1101,12 +1077,10 @@
11011077
.unwrap()
11021078
}
11031079
<span class="kw">_ </span>=&gt; {
1104-
<span class="kw">let </span>undef = <span class="self">self</span>.undef(ty).def(<span class="self">self</span>);
1105-
<span class="self">self</span>.zombie(
1106-
undef,
1080+
<span class="kw">return </span><span class="self">self</span>.undef_zombie(
1081+
ty,
11071082
<span class="kw-2">&amp;</span><span class="macro">format!</span>(<span class="string">"bit_reverse() on unsupported {ty:?} bit integer type"</span>),
11081083
);
1109-
undef
11101084
}
11111085
}
11121086
.with_type(ty)
@@ -1131,13 +1105,20 @@
11311105
<span class="kw">let </span>u32 = SpirvType::Integer(<span class="number">32</span>, <span class="bool-val">false</span>).def(<span class="self">self</span>.span(), <span class="self">self</span>);
11321106

11331107
<span class="kw">let </span>glsl = <span class="self">self</span>.ext_inst.borrow_mut().import_glsl(<span class="self">self</span>);
1134-
<span class="kw">let </span>find_xsb = |arg| {
1108+
<span class="kw">let </span>find_xsb = |arg, offset: i32| {
11351109
<span class="kw">if </span>trailing {
1136-
<span class="self">self</span>.emit()
1110+
<span class="kw">let </span>lsb = <span class="self">self
1111+
</span>.emit()
11371112
.ext_inst(u32, <span class="prelude-val">None</span>, glsl, GLOp::FindILsb <span class="kw">as </span>u32, [Operand::IdRef(
11381113
arg,
11391114
)])
1140-
.unwrap()
1115+
.unwrap();
1116+
<span class="kw">if </span>offset == <span class="number">0 </span>{
1117+
lsb
1118+
} <span class="kw">else </span>{
1119+
<span class="kw">let </span>const_offset = <span class="self">self</span>.constant_i32(<span class="self">self</span>.span(), offset).def(<span class="self">self</span>);
1120+
<span class="self">self</span>.emit().i_add(u32, <span class="prelude-val">None</span>, const_offset, lsb).unwrap()
1121+
}
11411122
} <span class="kw">else </span>{
11421123
<span class="comment">// rust is always unsigned, so FindUMsb
11431124
</span><span class="kw">let </span>msb_bit = <span class="self">self
@@ -1148,25 +1129,21 @@
11481129
.unwrap();
11491130
<span class="comment">// the glsl op returns the Msb bit, not the amount of leading zeros of this u32
11501131
// leading zeros = 31 - Msb bit
1151-
</span><span class="kw">let </span>u32_31 = <span class="self">self</span>.constant_u32(<span class="self">self</span>.span(), <span class="number">31</span>).def(<span class="self">self</span>);
1152-
<span class="self">self</span>.emit().i_sub(u32, <span class="prelude-val">None</span>, u32_31, msb_bit).unwrap()
1132+
</span><span class="kw">let </span>const_offset = <span class="self">self</span>.constant_i32(<span class="self">self</span>.span(), <span class="number">31 </span>- offset).def(<span class="self">self</span>);
1133+
<span class="self">self</span>.emit().i_sub(u32, <span class="prelude-val">None</span>, const_offset, msb_bit).unwrap()
11531134
}
11541135
};
11551136

11561137
<span class="kw">let </span>converted = <span class="kw">match </span>bits {
11571138
<span class="number">8 </span>| <span class="number">16 </span>=&gt; {
1139+
<span class="kw">let </span>arg = <span class="self">self</span>.emit().u_convert(u32, <span class="prelude-val">None</span>, arg.def(<span class="self">self</span>)).unwrap();
11581140
<span class="kw">if </span>trailing {
1159-
<span class="kw">let </span>arg = <span class="self">self</span>.emit().u_convert(u32, <span class="prelude-val">None</span>, arg.def(<span class="self">self</span>)).unwrap();
1160-
find_xsb(arg)
1141+
find_xsb(arg, <span class="number">0</span>)
11611142
} <span class="kw">else </span>{
1162-
<span class="kw">let </span>arg = arg.def(<span class="self">self</span>);
1163-
<span class="kw">let </span>arg = <span class="self">self</span>.emit().u_convert(u32, <span class="prelude-val">None</span>, arg).unwrap();
1164-
<span class="kw">let </span>xsb = find_xsb(arg);
1165-
<span class="kw">let </span>subtrahend = <span class="self">self</span>.constant_u32(<span class="self">self</span>.span(), <span class="number">32 </span>- bits).def(<span class="self">self</span>);
1166-
<span class="self">self</span>.emit().i_sub(u32, <span class="prelude-val">None</span>, xsb, subtrahend).unwrap()
1143+
find_xsb(arg, bits <span class="kw">as </span>i32 - <span class="number">32</span>)
11671144
}
11681145
}
1169-
<span class="number">32 </span>=&gt; find_xsb(arg.def(<span class="self">self</span>)),
1146+
<span class="number">32 </span>=&gt; find_xsb(arg.def(<span class="self">self</span>), <span class="number">0</span>),
11701147
<span class="number">64 </span>=&gt; {
11711148
<span class="kw">let </span>u32_0 = <span class="self">self</span>.constant_int(u32, <span class="number">0</span>).def(<span class="self">self</span>);
11721149
<span class="kw">let </span>u32_32 = <span class="self">self</span>.constant_u32(<span class="self">self</span>.span(), <span class="number">32</span>).def(<span class="self">self</span>);
@@ -1179,31 +1156,26 @@
11791156
.unwrap();
11801157
<span class="kw">let </span>higher = <span class="self">self</span>.emit().u_convert(u32, <span class="prelude-val">None</span>, higher).unwrap();
11811158

1182-
<span class="kw">let </span>lower_bits = find_xsb(lower);
1183-
<span class="kw">let </span>higher_bits = find_xsb(higher);
1184-
11851159
<span class="kw">if </span>trailing {
11861160
<span class="kw">let </span>use_lower = <span class="self">self</span>.emit().i_equal(bool, <span class="prelude-val">None</span>, higher, u32_0).unwrap();
1187-
<span class="kw">let </span>lower_bits =
1188-
<span class="self">self</span>.emit().i_add(u32, <span class="prelude-val">None</span>, lower_bits, u32_32).unwrap();
1161+
<span class="kw">let </span>lower_bits = find_xsb(lower, <span class="number">32</span>);
1162+
<span class="kw">let </span>higher_bits = find_xsb(higher, <span class="number">0</span>);
11891163
<span class="self">self</span>.emit()
11901164
.select(u32, <span class="prelude-val">None</span>, use_lower, lower_bits, higher_bits)
11911165
.unwrap()
11921166
} <span class="kw">else </span>{
11931167
<span class="kw">let </span>use_higher = <span class="self">self</span>.emit().i_equal(bool, <span class="prelude-val">None</span>, lower, u32_0).unwrap();
1194-
<span class="kw">let </span>higher_bits =
1195-
<span class="self">self</span>.emit().i_add(u32, <span class="prelude-val">None</span>, higher_bits, u32_32).unwrap();
1168+
<span class="kw">let </span>lower_bits = find_xsb(lower, <span class="number">0</span>);
1169+
<span class="kw">let </span>higher_bits = find_xsb(higher, <span class="number">32</span>);
11961170
<span class="self">self</span>.emit()
11971171
.select(u32, <span class="prelude-val">None</span>, use_higher, higher_bits, lower_bits)
11981172
.unwrap()
11991173
}
12001174
}
12011175
<span class="kw">_ </span>=&gt; {
1202-
<span class="kw">let </span>undef = <span class="self">self</span>.undef(ty).def(<span class="self">self</span>);
1203-
<span class="self">self</span>.zombie(undef, <span class="kw-2">&amp;</span><span class="macro">format!</span>(
1176+
<span class="kw">return </span><span class="self">self</span>.undef_zombie(ty, <span class="kw-2">&amp;</span><span class="macro">format!</span>(
12041177
<span class="string">"count_leading_trailing_zeros() on unsupported {ty:?} bit integer type"
12051178
</span>));
1206-
undef
12071179
}
12081180
};
12091181

0 commit comments

Comments
 (0)