cfg_expr/
targets.rs

1use crate::error::{HasAtomicParseError, Reason};
2use std::{borrow::Cow, ops::Deref};
3
4mod builtins;
5
6/// A list of all of the [builtin](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_target/spec/index.html#modules)
7/// targets known to rustc, as of 1.54.0
8pub use builtins::ALL_BUILTINS;
9
10/// The unique identifier for a target.
11#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
12pub struct Triple(pub Cow<'static, str>);
13
14/// The "abi" field
15#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
16pub struct Abi(pub Cow<'static, str>);
17
18/// The "architecture" field
19#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
20pub struct Arch(pub Cow<'static, str>);
21
22/// The "vendor" field, which in practice is little more than an arbitrary modifier.
23#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
24pub struct Vendor(pub Cow<'static, str>);
25
26/// The "operating system" field, which sometimes implies an environment, and
27/// sometimes isn't an actual operating system.
28#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
29pub struct Os(pub Cow<'static, str>);
30
31/// Individual target families, which describe a set of targets grouped in some logical manner,
32/// typically by operating system. This includes values like `unix` and `windows`.
33#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
34pub struct Family(pub Cow<'static, str>);
35
36/// The "environment" field, which specifies an ABI environment on top of the
37/// operating system. In many configurations, this field is omitted, and the
38/// environment is implied by the operating system.
39#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
40pub struct Env(pub Cow<'static, str>);
41
42/// The panic strategy used on this target by default.
43#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
44pub struct Panic(pub Cow<'static, str>);
45
46macro_rules! field_impls {
47    ($kind:ident) => {
48        impl $kind {
49            /// Constructs a new instance of this field.
50            ///
51            /// This method accepts both owned `String`s and `&'static str`s.
52            #[inline]
53            pub fn new(val: impl Into<Cow<'static, str>>) -> Self {
54                Self(val.into())
55            }
56
57            /// Constructs a new instance of this field from a `&'static str`.
58            #[inline]
59            pub const fn new_const(val: &'static str) -> Self {
60                Self(Cow::Borrowed(val))
61            }
62
63            /// Returns the string for the field.
64            #[inline]
65            pub fn as_str(&self) -> &str {
66                &*self.0
67            }
68        }
69
70        impl AsRef<str> for $kind {
71            #[inline]
72            fn as_ref(&self) -> &str {
73                &*self.0
74            }
75        }
76
77        impl std::fmt::Display for $kind {
78            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
79                f.write_str(self.as_str())
80            }
81        }
82    };
83}
84
85field_impls!(Triple);
86field_impls!(Abi);
87field_impls!(Arch);
88field_impls!(Vendor);
89field_impls!(Os);
90field_impls!(Family);
91field_impls!(Env);
92field_impls!(Panic);
93
94/// Integer size and pointers for which there's support for atomic functions.
95#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
96#[non_exhaustive]
97pub enum HasAtomic {
98    /// The platform supports atomics for the given integer size in bits (e.g. `AtomicU8` if
99    /// `HasAtomic::IntegerSize(8)`).
100    IntegerSize(u16),
101
102    /// The platform supports atomics for pointers (`AtomicPtr`).
103    Pointer,
104}
105
106impl std::str::FromStr for HasAtomic {
107    type Err = HasAtomicParseError;
108
109    fn from_str(s: &str) -> Result<Self, Self::Err> {
110        if let Ok(size) = s.parse::<u16>() {
111            Ok(Self::IntegerSize(size))
112        } else if s == "ptr" {
113            Ok(HasAtomic::Pointer)
114        } else {
115            Err(HasAtomicParseError {
116                input: s.to_owned(),
117            })
118        }
119    }
120}
121
122impl std::fmt::Display for HasAtomic {
123    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
124        match self {
125            Self::IntegerSize(size) => write!(f, "{size}"),
126            Self::Pointer => write!(f, "ptr"),
127        }
128    }
129}
130
131/// A set of families for a target.
132///
133/// Each target can be part of one or more families. This struct represents them.
134#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
135pub struct Families(Cow<'static, [Family]>);
136
137impl Families {
138    /// Constructs a new instance.
139    ///
140    /// This method accepts both owned `String`s and `&'static str`s.
141    ///
142    /// If you have a `&'static [&'static str]`, prefer [`Self::new_const`].
143    #[inline]
144    pub fn new(val: impl IntoIterator<Item = Family>) -> Self {
145        let mut fams: Vec<_> = val.into_iter().collect();
146        fams.sort_unstable();
147        Self(Cow::Owned(fams))
148    }
149
150    /// Constructs a new instance of this field from a static slice of `&'static str`.
151    ///
152    /// `val` must be in sorted order: this constructor cannot check for that due to
153    /// limitations in current versions of Rust.
154    #[inline]
155    pub const fn new_const(val: &'static [Family]) -> Self {
156        // TODO: Check that val is sorted.
157        Self(Cow::Borrowed(val))
158    }
159
160    /// Returns true if this list of families contains a given family.
161    #[inline]
162    pub fn contains(&self, val: &Family) -> bool {
163        self.0.contains(val)
164    }
165}
166
167impl Deref for Families {
168    type Target = [Family];
169    fn deref(&self) -> &Self::Target {
170        &self.0
171    }
172}
173
174impl AsRef<[Family]> for Families {
175    #[inline]
176    fn as_ref(&self) -> &[Family] {
177        &self.0
178    }
179}
180
181impl std::fmt::Display for Families {
182    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
183        write!(f, "{{")?;
184        let len = self.0.len();
185        for (idx, family) in self.0.iter().enumerate() {
186            write!(f, "{family}")?;
187            if idx + 1 < len {
188                write!(f, ", ")?;
189            }
190        }
191        write!(f, "}}")
192    }
193}
194
195/// A set of [`HasAtomic`] instances a target.
196#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
197pub struct HasAtomics(Cow<'static, [HasAtomic]>);
198
199impl HasAtomics {
200    /// Constructs a new instance.
201    ///
202    /// If you have a `&'static [HasAtomic]`, prefer [`Self::new_const`].
203    #[inline]
204    pub fn new(val: impl IntoIterator<Item = HasAtomic>) -> Self {
205        let mut has_atomics: Vec<_> = val.into_iter().collect();
206        has_atomics.sort_unstable();
207        Self(Cow::Owned(has_atomics))
208    }
209
210    /// Constructs a new instance of this struct from a static slice of [`HasAtomic`].
211    ///
212    /// `val` must be in sorted order: this constructor cannot check for that due to
213    /// limitations in current versions of Rust.
214    #[inline]
215    pub const fn new_const(val: &'static [HasAtomic]) -> Self {
216        // TODO: Check that val is sorted.
217        Self(Cow::Borrowed(val))
218    }
219
220    /// Returns true if this list of families contains a given family.
221    #[inline]
222    pub fn contains(&self, val: HasAtomic) -> bool {
223        self.0.contains(&val)
224    }
225}
226
227impl Deref for HasAtomics {
228    type Target = [HasAtomic];
229    fn deref(&self) -> &Self::Target {
230        &self.0
231    }
232}
233
234impl AsRef<[HasAtomic]> for HasAtomics {
235    #[inline]
236    fn as_ref(&self) -> &[HasAtomic] {
237        &self.0
238    }
239}
240
241impl std::fmt::Display for HasAtomics {
242    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
243        write!(f, "{{")?;
244        let len = self.0.len();
245        for (idx, has_atomic) in self.0.iter().enumerate() {
246            write!(f, "{has_atomic}")?;
247            if idx + 1 < len {
248                write!(f, ", ")?;
249            }
250        }
251        write!(f, "}}")
252    }
253}
254
255macro_rules! target_enum {
256    (
257        $(#[$outer:meta])*
258        pub enum $kind:ident {
259            $(
260                $(#[$inner:ident $($args:tt)*])*
261                $name:ident $(= $value:expr)?,
262            )+
263        }
264    ) => {
265        $(#[$outer])*
266        #[allow(non_camel_case_types)]
267        pub enum $kind {
268            $(
269                $(#[$inner $($args)*])*
270                $name $(= $value)?,
271            )+
272        }
273
274        impl_from_str! {
275            $kind {
276                $(
277                    $(#[$inner $($args)*])*
278                    $name $(= $value)?,
279                )+
280            }
281        }
282    };
283}
284
285macro_rules! impl_from_str {
286    (
287        $kind:ident {
288            $(
289                $(#[$attr:ident $($args:tt)*])*
290                $name:ident $(= $value:expr)?,
291            )+
292        }
293    ) => {
294        impl std::str::FromStr for $kind {
295            type Err = Reason;
296            fn from_str(s: &str) -> Result<Self, Self::Err> {
297                match s {
298                    $(stringify!($name) => Ok(Self::$name),)+
299                    _ => Err(Reason::Unexpected(&[$(stringify!($name),)+])),
300                }
301            }
302        }
303    };
304}
305
306target_enum! {
307    /// The endian types known to rustc
308    #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
309    pub enum Endian {
310        big,
311        little,
312    }
313}
314
315/// Contains information regarding a particular target known to rustc
316#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
317pub struct TargetInfo {
318    /// The target's unique identifier
319    pub triple: Triple,
320    /// The target's operating system, if any. Used by the
321    /// [target_os](https://doc.rust-lang.org/reference/conditional-compilation.html#target_os)
322    /// predicate.
323    pub os: Option<Os>,
324    /// The target's ABI, if any. Used by the
325    /// [target_abi](https://github.com/rust-lang/rust/issues/80970) predicate.
326    pub abi: Option<Abi>,
327    /// The target's CPU architecture. Used by the
328    /// [target_arch](https://doc.rust-lang.org/reference/conditional-compilation.html#target_arch)
329    /// predicate.
330    pub arch: Arch,
331    /// The target's ABI/libc used, if any. Used by the
332    /// [target_env](https://doc.rust-lang.org/reference/conditional-compilation.html#target_env)
333    /// predicate.
334    pub env: Option<Env>,
335    /// The target's vendor, if any. Used by the
336    /// [target_vendor](https://doc.rust-lang.org/reference/conditional-compilation.html#target_vendor)
337    /// predicate.
338    pub vendor: Option<Vendor>,
339    /// The target's families, if any. Used by the
340    /// [target_family](https://doc.rust-lang.org/reference/conditional-compilation.html#target_family)
341    /// predicate.
342    pub families: Families,
343    /// The size of the target's pointer type. Used by the
344    /// [target_pointer_width](https://doc.rust-lang.org/reference/conditional-compilation.html#target_pointer_width)
345    /// predicate.
346    pub pointer_width: u8,
347    /// The target's endianness. Used by the
348    /// [target_endian](https://doc.rust-lang.org/reference/conditional-compilation.html#target_endian)
349    /// predicate.
350    pub endian: Endian,
351    /// The target's support for atomics. Used by the `has_target_atomics` predicate.
352    pub has_atomics: HasAtomics,
353    /// The panic strategy used on this target by default. Used by the
354    /// [panic](https://doc.rust-lang.org/beta/reference/conditional-compilation.html#panic) predicate.
355    pub panic: Panic,
356}
357
358/// Attempts to find the `TargetInfo` for the specified target triple
359///
360/// ```
361/// assert!(cfg_expr::targets::get_builtin_target_by_triple("x86_64-unknown-linux-musl").is_some());
362/// ```
363pub fn get_builtin_target_by_triple(triple: &str) -> Option<&'static TargetInfo> {
364    ALL_BUILTINS
365        .binary_search_by(|ti| ti.triple.as_ref().cmp(triple))
366        .map(|i| &ALL_BUILTINS[i])
367        .ok()
368}
369
370/// Retrieves the version of rustc for which the built-in targets were
371/// retrieved from.
372///
373/// Targets may be added and removed between different rustc versions.
374pub fn rustc_version() -> &'static str {
375    builtins::RUSTC_VERSION
376}
377
378#[cfg(test)]
379mod test {
380    use crate::targets::get_builtin_target_by_triple;
381    use std::collections::{BTreeSet, HashSet};
382
383    // rustc's target-list is currently sorted lexicographically
384    // by the target-triple, so ensure that stays the case
385    #[test]
386    fn targets_are_sorted() {
387        for window in super::ALL_BUILTINS.windows(2) {
388            assert!(window[0].triple < window[1].triple);
389        }
390    }
391
392    // Ensure our workaround for https://github.com/rust-lang/rust/issues/36156
393    // still functions
394    #[test]
395    fn has_ios() {
396        assert_eq!(
397            8,
398            super::ALL_BUILTINS
399                .iter()
400                .filter(|ti| ti.os == Some(super::Os::ios))
401                .count()
402        );
403    }
404
405    // Ensure that TargetInfo can be used as keys for btree and hash-based data structures.
406    #[test]
407    fn set_map_key() {
408        let target_info =
409            get_builtin_target_by_triple("x86_64-unknown-linux-gnu").expect("known target");
410
411        let mut btree_set = BTreeSet::new();
412        btree_set.insert(target_info);
413
414        let mut hash_set = HashSet::new();
415        hash_set.insert(target_info);
416    }
417
418    #[test]
419    fn family_comp() {
420        let a = super::Families::new([super::Family::unix, super::Family::wasm]);
421        let b = super::Families::new([super::Family::wasm, super::Family::unix]);
422
423        assert_eq!(a, b);
424    }
425}
cfg_expr/targets.rs

cfg_expr/
targets.rs
