Skip to content

Commit 6fb6c19

Browse files
tgross35tgross35
committed
Replace f16 and f128 pattern matching stubs with real implementations
This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`.
1 parent acb6273 commit 6fb6c19

File tree

11 files changed

+309
-38
lines changed

11 files changed

+309
-38
lines changed

‎compiler/rustc_middle/src/thir.rs‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1047,6 +1047,12 @@ impl<'tcx> PatRangeBoundary<'tcx> {
10471047
let b = other.eval_bits(ty, tcx, param_env);
10481048

10491049
match ty.kind() {
1050+
ty::Float(ty::FloatTy::F16) => {
1051+
use rustc_apfloat::Float;
1052+
let a = rustc_apfloat::ieee::Half::from_bits(a);
1053+
let b = rustc_apfloat::ieee::Half::from_bits(b);
1054+
a.partial_cmp(&b)
1055+
}
10501056
ty::Float(ty::FloatTy::F32) => {
10511057
use rustc_apfloat::Float;
10521058
let a = rustc_apfloat::ieee::Single::from_bits(a);
@@ -1059,6 +1065,12 @@ impl<'tcx> PatRangeBoundary<'tcx> {
10591065
let b = rustc_apfloat::ieee::Double::from_bits(b);
10601066
a.partial_cmp(&b)
10611067
}
1068+
ty::Float(ty::FloatTy::F128) => {
1069+
use rustc_apfloat::Float;
1070+
let a = rustc_apfloat::ieee::Quad::from_bits(a);
1071+
let b = rustc_apfloat::ieee::Quad::from_bits(b);
1072+
a.partial_cmp(&b)
1073+
}
10621074
ty::Int(ity) => {
10631075
let size = rustc_target::abi::Integer::from_int_ty(&tcx, *ity).size();
10641076
let a = size.sign_extend(a) as i128;

‎compiler/rustc_middle/src/ty/util.rs‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1196,7 +1196,7 @@ impl<'tcx> Ty<'tcx> {
11961196
/// Returns the minimum and maximum values for the given numeric type (including `char`s) or
11971197
/// returns `None` if the type is not numeric.
11981198
pub fn numeric_min_and_max_as_bits(self, tcx: TyCtxt<'tcx>) -> Option<(u128, u128)> {
1199-
use rustc_apfloat::ieee::{Double, Single};
1199+
use rustc_apfloat::ieee::{Double, Half, Quad, Single};
12001200
Some(match self.kind() {
12011201
ty::Int(_) | ty::Uint(_) => {
12021202
let (size, signed) = self.int_size_and_signed(tcx);
@@ -1206,12 +1206,14 @@ impl<'tcx> Ty<'tcx> {
12061206
(min, max)
12071207
}
12081208
ty::Char => (0, std::char::MAX as u128),
1209+
ty::Float(ty::FloatTy::F16) => ((-Half::INFINITY).to_bits(), Half::INFINITY.to_bits()),
12091210
ty::Float(ty::FloatTy::F32) => {
12101211
((-Single::INFINITY).to_bits(), Single::INFINITY.to_bits())
12111212
}
12121213
ty::Float(ty::FloatTy::F64) => {
12131214
((-Double::INFINITY).to_bits(), Double::INFINITY.to_bits())
12141215
}
1216+
ty::Float(ty::FloatTy::F128) => ((-Quad::INFINITY).to_bits(), Quad::INFINITY.to_bits()),
12151217
_ => return None,
12161218
})
12171219
}

‎compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -369,10 +369,10 @@ impl<'tcx> ConstToPat<'tcx> {
369369
ty::Float(flt) => {
370370
let v = cv.unwrap_leaf();
371371
let is_nan = match flt {
372-
ty::FloatTy::F16 => unimplemented!("f16_f128"),
372+
ty::FloatTy::F16 => v.to_f16().is_nan(),
373373
ty::FloatTy::F32 => v.to_f32().is_nan(),
374374
ty::FloatTy::F64 => v.to_f64().is_nan(),
375-
ty::FloatTy::F128 => unimplemented!("f16_f128"),
375+
ty::FloatTy::F128 => v.to_f128().is_nan(),
376376
};
377377
if is_nan {
378378
// NaNs are not ever equal to anything so they make no sense as patterns.

‎compiler/rustc_pattern_analysis/src/constructor.rs‎

Lines changed: 26 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -182,7 +182,7 @@ use std::iter::once;
182182

183183
use smallvec::SmallVec;
184184

185-
use rustc_apfloat::ieee::{DoubleS, IeeeFloat, SingleS};
185+
use rustc_apfloat::ieee::{DoubleS, HalfS, IeeeFloat, QuadS, SingleS};
186186
use rustc_index::bit_set::{BitSet, GrowableBitSet};
187187
use rustc_index::IndexVec;
188188

@@ -692,8 +692,10 @@ pub enum Constructor<Cx: PatCx> {
692692
/// Ranges of integer literal values (`2`, `2..=5` or `2..5`).
693693
IntRange(IntRange),
694694
/// Ranges of floating-point literal values (`2.0..=5.2`).
695+
F16Range(IeeeFloat<HalfS>, IeeeFloat<HalfS>, RangeEnd),
695696
F32Range(IeeeFloat<SingleS>, IeeeFloat<SingleS>, RangeEnd),
696697
F64Range(IeeeFloat<DoubleS>, IeeeFloat<DoubleS>, RangeEnd),
698+
F128Range(IeeeFloat<QuadS>, IeeeFloat<QuadS>, RangeEnd),
697699
/// String literals. Strings are not quite the same as `&[u8]` so we treat them separately.
698700
Str(Cx::StrLit),
699701
/// Constants that must not be matched structurally. They are treated as black boxes for the
@@ -735,8 +737,10 @@ impl<Cx: PatCx> Clone for Constructor<Cx> {
735737
Constructor::UnionField => Constructor::UnionField,
736738
Constructor::Bool(b) => Constructor::Bool(*b),
737739
Constructor::IntRange(range) => Constructor::IntRange(*range),
740+
Constructor::F16Range(lo, hi, end) => Constructor::F16Range(lo.clone(), *hi, *end),
738741
Constructor::F32Range(lo, hi, end) => Constructor::F32Range(lo.clone(), *hi, *end),
739742
Constructor::F64Range(lo, hi, end) => Constructor::F64Range(lo.clone(), *hi, *end),
743+
Constructor::F128Range(lo, hi, end) => Constructor::F128Range(lo.clone(), *hi, *end),
740744
Constructor::Str(value) => Constructor::Str(value.clone()),
741745
Constructor::Opaque(inner) => Constructor::Opaque(inner.clone()),
742746
Constructor::Or => Constructor::Or,
@@ -812,6 +816,14 @@ impl<Cx: PatCx> Constructor<Cx> {
812816
(Bool(self_b), Bool(other_b)) => self_b == other_b,
813817

814818
(IntRange(self_range), IntRange(other_range)) => self_range.is_subrange(other_range),
819+
(F16Range(self_from, self_to, self_end), F16Range(other_from, other_to, other_end)) => {
820+
self_from.ge(other_from)
821+
&& match self_to.partial_cmp(other_to) {
822+
Some(Ordering::Less) => true,
823+
Some(Ordering::Equal) => other_end == self_end,
824+
_ => false,
825+
}
826+
}
815827
(F32Range(self_from, self_to, self_end), F32Range(other_from, other_to, other_end)) => {
816828
self_from.ge(other_from)
817829
&& match self_to.partial_cmp(other_to) {
@@ -828,6 +840,17 @@ impl<Cx: PatCx> Constructor<Cx> {
828840
_ => false,
829841
}
830842
}
843+
(
844+
F128Range(self_from, self_to, self_end),
845+
F128Range(other_from, other_to, other_end),
846+
) => {
847+
self_from.ge(other_from)
848+
&& match self_to.partial_cmp(other_to) {
849+
Some(Ordering::Less) => true,
850+
Some(Ordering::Equal) => other_end == self_end,
851+
_ => false,
852+
}
853+
}
831854
(Str(self_val), Str(other_val)) => {
832855
// FIXME Once valtrees are available we can directly use the bytes
833856
// in the `Str` variant of the valtree for the comparison here.
@@ -906,8 +929,10 @@ impl<Cx: PatCx> Constructor<Cx> {
906929
Bool(b) => write!(f, "{b}")?,
907930
// Best-effort, will render signed ranges incorrectly
908931
IntRange(range) => write!(f, "{range:?}")?,
932+
F16Range(lo, hi, end) => write!(f, "{lo}{end}{hi}")?,
909933
F32Range(lo, hi, end) => write!(f, "{lo}{end}{hi}")?,
910934
F64Range(lo, hi, end) => write!(f, "{lo}{end}{hi}")?,
935+
F128Range(lo, hi, end) => write!(f, "{lo}{end}{hi}")?,
911936
Str(value) => write!(f, "{value:?}")?,
912937
Opaque(..) => write!(f, "<constant pattern>")?,
913938
Or => {

‎compiler/rustc_pattern_analysis/src/rustc.rs‎

Lines changed: 43 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -247,8 +247,9 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
247247
}
248248
_ => bug!("bad slice pattern {:?} {:?}", ctor, ty),
249249
},
250-
Bool(..) | IntRange(..) | F32Range(..) | F64Range(..) | Str(..) | Opaque(..)
251-
| Never | NonExhaustive | Hidden | Missing | PrivateUninhabited | Wildcard => &[],
250+
Bool(..) | IntRange(..) | F16Range(..) | F32Range(..) | F64Range(..)
251+
| F128Range(..) | Str(..) | Opaque(..) | Never | NonExhaustive | Hidden | Missing
252+
| PrivateUninhabited | Wildcard => &[],
252253
Or => {
253254
bug!("called `Fields::wildcards` on an `Or` ctor")
254255
}
@@ -275,8 +276,9 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
275276
},
276277
Ref => 1,
277278
Slice(slice) => slice.arity(),
278-
Bool(..) | IntRange(..) | F32Range(..) | F64Range(..) | Str(..) | Opaque(..)
279-
| Never | NonExhaustive | Hidden | Missing | PrivateUninhabited | Wildcard => 0,
279+
Bool(..) | IntRange(..) | F16Range(..) | F32Range(..) | F64Range(..)
280+
| F128Range(..) | Str(..) | Opaque(..) | Never | NonExhaustive | Hidden | Missing
281+
| PrivateUninhabited | Wildcard => 0,
280282
Or => bug!("The `Or` constructor doesn't have a fixed arity"),
281283
}
282284
}
@@ -546,6 +548,18 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
546548
fields = vec![];
547549
arity = 0;
548550
}
551+
ty::Float(ty::FloatTy::F16) => {
552+
ctor = match value.try_eval_bits(cx.tcx, cx.param_env) {
553+
Some(bits) => {
554+
use rustc_apfloat::Float;
555+
let value = rustc_apfloat::ieee::Half::from_bits(bits);
556+
F16Range(value, value, RangeEnd::Included)
557+
}
558+
None => Opaque(OpaqueId::new()),
559+
};
560+
fields = vec![];
561+
arity = 0;
562+
}
549563
ty::Float(ty::FloatTy::F32) => {
550564
ctor = match value.try_eval_bits(cx.tcx, cx.param_env) {
551565
Some(bits) => {
@@ -570,6 +584,18 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
570584
fields = vec![];
571585
arity = 0;
572586
}
587+
ty::Float(ty::FloatTy::F128) => {
588+
ctor = match value.try_eval_bits(cx.tcx, cx.param_env) {
589+
Some(bits) => {
590+
use rustc_apfloat::Float;
591+
let value = rustc_apfloat::ieee::Quad::from_bits(bits);
592+
F128Range(value, value, RangeEnd::Included)
593+
}
594+
None => Opaque(OpaqueId::new()),
595+
};
596+
fields = vec![];
597+
arity = 0;
598+
}
573599
ty::Ref(_, t, _) if t.is_str() => {
574600
// We want a `&str` constant to behave like a `Deref` pattern, to be compatible
575601
// with other `Deref` patterns. This could have been done in `const_to_pat`,
@@ -611,7 +637,12 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
611637
let lo = lo.as_finite().map(|c| c.eval_bits(cx.tcx, cx.param_env));
612638
let hi = hi.as_finite().map(|c| c.eval_bits(cx.tcx, cx.param_env));
613639
match fty {
614-
ty::FloatTy::F16 => unimplemented!("f16_f128"),
640+
ty::FloatTy::F16 => {
641+
use rustc_apfloat::ieee::Half;
642+
let lo = lo.map(Half::from_bits).unwrap_or(-Half::INFINITY);
643+
let hi = hi.map(Half::from_bits).unwrap_or(Half::INFINITY);
644+
F16Range(lo, hi, end)
645+
}
615646
ty::FloatTy::F32 => {
616647
use rustc_apfloat::ieee::Single;
617648
let lo = lo.map(Single::from_bits).unwrap_or(-Single::INFINITY);
@@ -624,7 +655,12 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
624655
let hi = hi.map(Double::from_bits).unwrap_or(Double::INFINITY);
625656
F64Range(lo, hi, end)
626657
}
627-
ty::FloatTy::F128 => unimplemented!("f16_f128"),
658+
ty::FloatTy::F128 => {
659+
use rustc_apfloat::ieee::Quad;
660+
let lo = lo.map(Quad::from_bits).unwrap_or(-Quad::INFINITY);
661+
let hi = hi.map(Quad::from_bits).unwrap_or(Quad::INFINITY);
662+
F128Range(lo, hi, end)
663+
}
628664
}
629665
}
630666
_ => bug!("invalid type for range pattern: {}", ty.inner()),
@@ -837,7 +873,7 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
837873
"trying to convert a `Missing` constructor into a `Pat`; this is probably a bug,
838874
`Missing` should have been processed in `apply_constructors`"
839875
),
840-
F32Range(..) | F64Range(..) | Opaque(..) | Or => {
876+
F16Range(..) | F32Range(..) | F64Range(..) | F128Range(..) | Opaque(..) | Or => {
841877
bug!("can't convert to pattern: {:?}", pat)
842878
}
843879
};

‎tests/ui/half-open-range-patterns/half-open-range-pats-semantics.rs‎

Lines changed: 78 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,8 @@
44
// via `.contains(...)` and make sure the dynamic semantics match.
55

66
#![allow(unreachable_patterns)]
7+
#![feature(f128)]
8+
#![feature(f16)]
79

810
macro_rules! yes {
911
($scrutinee:expr, $($t:tt)+) => {
@@ -39,6 +41,17 @@ fn range_to_inclusive() {
3941
assert!(yes!('a', ..='a'));
4042
assert!(!yes!('b', ..='a'));
4143

44+
// f16; `..=X`
45+
// FIXME(f16_f128): remove gate when ABI issues are resolved
46+
#[cfg(all(target_arch = "aarch64", target_os = "linux"))]
47+
{
48+
// FIXME(f16_f128): enable infinity tests when constants are available
49+
// assert!(yes!(f16::NEG_INFINITY, ..=f16::NEG_INFINITY));
50+
// assert!(yes!(f16::NEG_INFINITY, ..=1.0f16));
51+
assert!(yes!(1.5f16, ..=1.5f16));
52+
assert!(!yes!(1.6f16, ..=-1.5f16));
53+
}
54+
4255
// f32; `..=X`
4356
assert!(yes!(f32::NEG_INFINITY, ..=f32::NEG_INFINITY));
4457
assert!(yes!(f32::NEG_INFINITY, ..=1.0f32));
@@ -50,6 +63,17 @@ fn range_to_inclusive() {
5063
assert!(yes!(f64::NEG_INFINITY, ..=1.0f64));
5164
assert!(yes!(1.5f64, ..=1.5f64));
5265
assert!(!yes!(1.6f64, ..=-1.5f64));
66+
67+
// f128; `..=X`
68+
// FIXME(f16_f128): remove gate when ABI issues are resolved
69+
#[cfg(all(target_arch = "aarch64", target_os = "linux"))]
70+
{
71+
// FIXME(f16_f128): enable infinity tests when constants are available
72+
// assert!(yes!(f128::NEG_INFINITY, ..=f128::NEG_INFINITY));
73+
// assert!(yes!(f128::NEG_INFINITY, ..=1.0f128));
74+
assert!(yes!(1.5f128, ..=1.5f128));
75+
assert!(!yes!(1.6f128, ..=-1.5f128));
76+
}
5377
}
5478

5579
fn range_to() {
@@ -83,6 +107,18 @@ fn range_to() {
83107
assert!(!yes!('a', ..'a'));
84108
assert!(!yes!('b', ..'a'));
85109

110+
// f16; `..X`
111+
// FIXME(f16_f128): remove gate when ABI issues are resolved
112+
#[cfg(all(target_arch = "aarch64", target_os = "linux"))]
113+
{
114+
// FIXME(f16_f128): enable infinity tests when constants are available
115+
// assert!(yes!(f16::NEG_INFINITY, ..1.0f16));
116+
assert!(!yes!(1.5f16, ..1.5f16));
117+
const E16: f16 = 1.5f16 + f16::EPSILON;
118+
assert!(yes!(1.5f16, ..E16));
119+
assert!(!yes!(1.6f16, ..1.5f16));
120+
}
121+
86122
// f32; `..X`
87123
assert!(yes!(f32::NEG_INFINITY, ..1.0f32));
88124
assert!(!yes!(1.5f32, ..1.5f32));
@@ -96,6 +132,18 @@ fn range_to() {
96132
const E64: f64 = 1.5f64 + f64::EPSILON;
97133
assert!(yes!(1.5f64, ..E64));
98134
assert!(!yes!(1.6f64, ..1.5f64));
135+
136+
// f128; `..X`
137+
// FIXME(f16_f128): remove gate when ABI issues are resolved
138+
#[cfg(all(target_arch = "aarch64", target_os = "linux"))]
139+
{
140+
// FIXME(f16_f128): enable infinity tests when constants are available
141+
// assert!(yes!(f128::NEG_INFINITY, ..1.0f128));
142+
assert!(!yes!(1.5f128, ..1.5f128));
143+
const E128: f128 = 1.5f128 + f128::EPSILON;
144+
assert!(yes!(1.5f128, ..E128));
145+
assert!(!yes!(1.6f128, ..1.5f128));
146+
}
99147
}
100148

101149
fn range_from() {
@@ -129,6 +177,21 @@ fn range_from() {
129177
assert!(!yes!('a', 'b'..));
130178
assert!(yes!(core::char::MAX, core::char::MAX..));
131179

180+
// f16; `X..`
181+
// FIXME(f16_f128): remove gate when ABI issues are resolved
182+
#[cfg(all(target_arch = "aarch64", target_os = "linux"))]
183+
{
184+
// FIXME(f16_f128): enable infinity tests when constants are available
185+
// assert!(yes!(f16::NEG_INFINITY, f16::NEG_INFINITY..));
186+
// assert!(yes!(f16::INFINITY, f16::NEG_INFINITY..));
187+
// assert!(!yes!(f16::NEG_INFINITY, 1.0f16..));
188+
// assert!(yes!(f16::INFINITY, 1.0f16..));
189+
assert!(!yes!(1.0f16 - f16::EPSILON, 1.0f16..));
190+
assert!(yes!(1.0f16, 1.0f16..));
191+
// assert!(yes!(f16::INFINITY, 1.0f16..));
192+
// assert!(yes!(f16::INFINITY, f16::INFINITY..));
193+
}
194+
132195
// f32; `X..`
133196
assert!(yes!(f32::NEG_INFINITY, f32::NEG_INFINITY..));
134197
assert!(yes!(f32::INFINITY, f32::NEG_INFINITY..));
@@ -148,6 +211,21 @@ fn range_from() {
148211
assert!(yes!(1.0f64, 1.0f64..));
149212
assert!(yes!(f64::INFINITY, 1.0f64..));
150213
assert!(yes!(f64::INFINITY, f64::INFINITY..));
214+
215+
// f128; `X..`
216+
// FIXME(f16_f128): remove gate when ABI issues are resolved
217+
#[cfg(all(target_arch = "aarch64", target_os = "linux"))]
218+
{
219+
// FIXME(f16_f128): enable infinity tests when constants are available
220+
// assert!(yes!(f128::NEG_INFINITY, f128::NEG_INFINITY..));
221+
// assert!(yes!(f128::INFINITY, f128::NEG_INFINITY..));
222+
// assert!(!yes!(f128::NEG_INFINITY, 1.0f128..));
223+
// assert!(yes!(f128::INFINITY, 1.0f128..));
224+
assert!(!yes!(1.0f128 - f128::EPSILON, 1.0f128..));
225+
assert!(yes!(1.0f128, 1.0f128..));
226+
// assert!(yes!(f128::INFINITY, 1.0f128..));
227+
// assert!(yes!(f128::INFINITY, f128::INFINITY..));
228+
}
151229
}
152230

153231
fn main() {

‎tests/ui/half-open-range-patterns/half-open-range-pats-thir-lower-empty.rs‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,7 @@ fn main() {
2727
m!(0, ..i128::MIN);
2828
//~^ ERROR lower range bound must be less than upper
2929

30+
// FIXME(f16_f128): add tests when NEG_INFINITY is available
3031
m!(0f32, ..f32::NEG_INFINITY);
3132
//~^ ERROR lower range bound must be less than upper
3233
m!(0f64, ..f64::NEG_INFINITY);

‎tests/ui/half-open-range-patterns/half-open-range-pats-thir-lower-empty.stderr‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -59,19 +59,19 @@ LL | m!(0, ..i128::MIN);
5959
| ^^^^^^^^^^^
6060

6161
error[E0579]: lower range bound must be less than upper
62-
--> $DIR/half-open-range-pats-thir-lower-empty.rs:30:14
62+
--> $DIR/half-open-range-pats-thir-lower-empty.rs:31:14
6363
|
6464
LL | m!(0f32, ..f32::NEG_INFINITY);
6565
| ^^^^^^^^^^^^^^^^^^^
6666

6767
error[E0579]: lower range bound must be less than upper
68-
--> $DIR/half-open-range-pats-thir-lower-empty.rs:32:14
68+
--> $DIR/half-open-range-pats-thir-lower-empty.rs:33:14
6969
|
7070
LL | m!(0f64, ..f64::NEG_INFINITY);
7171
| ^^^^^^^^^^^^^^^^^^^
7272

7373
error[E0579]: lower range bound must be less than upper
74-
--> $DIR/half-open-range-pats-thir-lower-empty.rs:35:13
74+
--> $DIR/half-open-range-pats-thir-lower-empty.rs:36:13
7575
|
7676
LL | m!('a', ..'\u{0}');
7777
| ^^^^^^^^^

0 commit comments

Comments
 (0)