3a7dfda40a
Implement new asm! syntax from RFC 2850 This PR implements the new `asm!` syntax proposed in https://github.com/rust-lang/rfcs/pull/2850. # Design A large part of this PR revolves around taking an `asm!` macro invocation and plumbing it through all of the compiler layers down to LLVM codegen. Throughout the various stages, an `InlineAsm` generally consists of 3 components: - The template string, which is stored as an array of `InlineAsmTemplatePiece`. Each piece represents either a literal or a placeholder for an operand (just like format strings). ```rust pub enum InlineAsmTemplatePiece { String(String), Placeholder { operand_idx: usize, modifier: Option<char>, span: Span }, } ``` - The list of operands to the `asm!` (`in`, `[late]out`, `in[late]out`, `sym`, `const`). These are represented differently at each stage of lowering, but follow a common pattern: - `in`, `out` and `inout` all have an associated register class (`reg`) or explicit register (`"eax"`). - `inout` has 2 forms: one with a single expression that is both read from and written to, and one with two separate expressions for the input and output parts. - `out` and `inout` have a `late` flag (`lateout` / `inlateout`) to indicate that the register allocator is allowed to reuse an input register for this output. - `out` and the split variant of `inout` allow `_` to be specified for an output, which means that the output is discarded. This is used to allocate scratch registers for assembly code. - `sym` is a bit special since it only accepts a path expression, which must point to a `static` or a `fn`. - The options set at the end of the `asm!` macro. The only one that is particularly of interest to rustc is `NORETURN` which makes `asm!` return `!` instead of `()`. ```rust bitflags::bitflags! { pub struct InlineAsmOptions: u8 { const PURE = 1 << 0; const NOMEM = 1 << 1; const READONLY = 1 << 2; const PRESERVES_FLAGS = 1 << 3; const NORETURN = 1 << 4; const NOSTACK = 1 << 5; } } ``` ## AST `InlineAsm` is represented as an expression in the AST: ```rust pub struct InlineAsm { pub template: Vec<InlineAsmTemplatePiece>, pub operands: Vec<(InlineAsmOperand, Span)>, pub options: InlineAsmOptions, } pub enum InlineAsmRegOrRegClass { Reg(Symbol), RegClass(Symbol), } pub enum InlineAsmOperand { In { reg: InlineAsmRegOrRegClass, expr: P<Expr>, }, Out { reg: InlineAsmRegOrRegClass, late: bool, expr: Option<P<Expr>>, }, InOut { reg: InlineAsmRegOrRegClass, late: bool, expr: P<Expr>, }, SplitInOut { reg: InlineAsmRegOrRegClass, late: bool, in_expr: P<Expr>, out_expr: Option<P<Expr>>, }, Const { expr: P<Expr>, }, Sym { expr: P<Expr>, }, } ``` The `asm!` macro is implemented in librustc_builtin_macros and outputs an `InlineAsm` AST node. The template string is parsed using libfmt_macros, positional and named operands are resolved to explicit operand indicies. Since target information is not available to macro invocations, validation of the registers and register classes is deferred to AST lowering. ## HIR `InlineAsm` is represented as an expression in the HIR: ```rust pub struct InlineAsm<'hir> { pub template: &'hir [InlineAsmTemplatePiece], pub operands: &'hir [InlineAsmOperand<'hir>], pub options: InlineAsmOptions, } pub enum InlineAsmRegOrRegClass { Reg(InlineAsmReg), RegClass(InlineAsmRegClass), } pub enum InlineAsmOperand<'hir> { In { reg: InlineAsmRegOrRegClass, expr: Expr<'hir>, }, Out { reg: InlineAsmRegOrRegClass, late: bool, expr: Option<Expr<'hir>>, }, InOut { reg: InlineAsmRegOrRegClass, late: bool, expr: Expr<'hir>, }, SplitInOut { reg: InlineAsmRegOrRegClass, late: bool, in_expr: Expr<'hir>, out_expr: Option<Expr<'hir>>, }, Const { expr: Expr<'hir>, }, Sym { expr: Expr<'hir>, }, } ``` AST lowering is where `InlineAsmRegOrRegClass` is converted from `Symbol`s to an actual register or register class. If any modifiers are specified for a template string placeholder, these are validated against the set allowed for that operand type. Finally, explicit registers for inputs and outputs are checked for conflicts (same register used for different operands). ## Type checking Each register class has a whitelist of types that it may be used with. After the types of all operands have been determined, the `intrinsicck` pass will check that these types are in the whitelist. It also checks that split `inout` operands have compatible types and that `const` operands are integers or floats. Suggestions are emitted where needed if a template modifier should be used for an operand based on the type that was passed into it. ## HAIR `InlineAsm` is represented as an expression in the HAIR: ```rust crate enum ExprKind<'tcx> { // [..] InlineAsm { template: &'tcx [InlineAsmTemplatePiece], operands: Vec<InlineAsmOperand<'tcx>>, options: InlineAsmOptions, }, } crate enum InlineAsmOperand<'tcx> { In { reg: InlineAsmRegOrRegClass, expr: ExprRef<'tcx>, }, Out { reg: InlineAsmRegOrRegClass, late: bool, expr: Option<ExprRef<'tcx>>, }, InOut { reg: InlineAsmRegOrRegClass, late: bool, expr: ExprRef<'tcx>, }, SplitInOut { reg: InlineAsmRegOrRegClass, late: bool, in_expr: ExprRef<'tcx>, out_expr: Option<ExprRef<'tcx>>, }, Const { expr: ExprRef<'tcx>, }, SymFn { expr: ExprRef<'tcx>, }, SymStatic { expr: ExprRef<'tcx>, }, } ``` The only significant change compared to HIR is that `Sym` has been lowered to either a `SymFn` whose `expr` is a `Literal` ZST of the `fn`, or a `SymStatic` whose `expr` is a `StaticRef`. ## MIR `InlineAsm` is represented as a `Terminator` in the MIR: ```rust pub enum TerminatorKind<'tcx> { // [..] /// Block ends with an inline assembly block. This is a terminator since /// inline assembly is allowed to diverge. InlineAsm { /// The template for the inline assembly, with placeholders. template: &'tcx [InlineAsmTemplatePiece], /// The operands for the inline assembly, as `Operand`s or `Place`s. operands: Vec<InlineAsmOperand<'tcx>>, /// Miscellaneous options for the inline assembly. options: InlineAsmOptions, /// Destination block after the inline assembly returns, unless it is /// diverging (InlineAsmOptions::NORETURN). destination: Option<BasicBlock>, }, } pub enum InlineAsmOperand<'tcx> { In { reg: InlineAsmRegOrRegClass, value: Operand<'tcx>, }, Out { reg: InlineAsmRegOrRegClass, late: bool, place: Option<Place<'tcx>>, }, InOut { reg: InlineAsmRegOrRegClass, late: bool, in_value: Operand<'tcx>, out_place: Option<Place<'tcx>>, }, Const { value: Operand<'tcx>, }, SymFn { value: Box<Constant<'tcx>>, }, SymStatic { value: Box<Constant<'tcx>>, }, } ``` As part of HAIR lowering, `InOut` and `SplitInOut` operands are lowered to a split form with a separate `in_value` and `out_place`. Semantically, the `InlineAsm` terminator is similar to the `Call` terminator except that it has multiple output places where a `Call` only has a single return place output. The constant promotion pass is used to ensure that `const` operands are actually constants (using the same logic as `#[rustc_args_required_const]`). ## Codegen Operands are lowered one more time before being passed to LLVM codegen: ```rust pub enum InlineAsmOperandRef<'tcx, B: BackendTypes + ?Sized> { In { reg: InlineAsmRegOrRegClass, value: OperandRef<'tcx, B::Value>, }, Out { reg: InlineAsmRegOrRegClass, late: bool, place: Option<PlaceRef<'tcx, B::Value>>, }, InOut { reg: InlineAsmRegOrRegClass, late: bool, in_value: OperandRef<'tcx, B::Value>, out_place: Option<PlaceRef<'tcx, B::Value>>, }, Const { string: String, }, SymFn { instance: Instance<'tcx>, }, SymStatic { def_id: DefId, }, } ``` The operands are lowered to LLVM operands and constraint codes as follow: - `out` and the output part of `inout` operands are added first, as required by LLVM. Late output operands have a `=` prefix added to their constraint code, non-late output operands have a `=&` prefix added to their constraint code. - `in` operands are added normally. - `inout` operands are tied to the matching output operand. - `sym` operands are passed as function pointers or pointers, using the `"s"` constraint. - `const` operands are formatted to a string and directly inserted in the template string. The template string is converted to LLVM form: - `$` characters are escaped as `$$`. - `const` operands are converted to strings and inserted directly. - Placeholders are formatted as `${X:M}` where `X` is the operand index and `M` is the modifier character. Modifiers are converted from the Rust form to the LLVM form. The various options are converted to clobber constraints or LLVM attributes, refer to the [RFC](https://github.com/Amanieu/rfcs/blob/inline-asm/text/0000-inline-asm.md#mapping-to-llvm-ir) for more details. Note that LLVM is sometimes rather picky about what types it accepts for certain constraint codes so we sometimes need to insert conversions to/from a supported type. See the target-specific ISelLowering.cpp files in LLVM for details. # Adding support for new architectures Adding inline assembly support to an architecture is mostly a matter of defining the registers and register classes for that architecture. All the definitions for register classes are located in `src/librustc_target/asm/`. Additionally you will need to implement lowering of these register classes to LLVM constraint codes in `src/librustc_codegen_llvm/asm.rs`.
585 lines
23 KiB
Rust
585 lines
23 KiB
Rust
//! List of the active feature gates.
|
|
|
|
use super::{Feature, State};
|
|
|
|
use rustc_span::edition::Edition;
|
|
use rustc_span::symbol::{sym, Symbol};
|
|
use rustc_span::Span;
|
|
|
|
macro_rules! set {
|
|
($field: ident) => {{
|
|
fn f(features: &mut Features, _: Span) {
|
|
features.$field = true;
|
|
}
|
|
f as fn(&mut Features, Span)
|
|
}};
|
|
}
|
|
|
|
macro_rules! declare_features {
|
|
($(
|
|
$(#[doc = $doc:tt])* (active, $feature:ident, $ver:expr, $issue:expr, $edition:expr),
|
|
)+) => {
|
|
/// Represents active features that are currently being implemented or
|
|
/// currently being considered for addition/removal.
|
|
pub const ACTIVE_FEATURES:
|
|
&[Feature] =
|
|
&[$(
|
|
// (sym::$feature, $ver, $issue, $edition, set!($feature))
|
|
Feature {
|
|
state: State::Active { set: set!($feature) },
|
|
name: sym::$feature,
|
|
since: $ver,
|
|
issue: $issue,
|
|
edition: $edition,
|
|
description: concat!($($doc,)*),
|
|
}
|
|
),+];
|
|
|
|
/// A set of features to be used by later passes.
|
|
#[derive(Clone, Default)]
|
|
pub struct Features {
|
|
/// `#![feature]` attrs for language features, for error reporting.
|
|
pub declared_lang_features: Vec<(Symbol, Span, Option<Symbol>)>,
|
|
/// `#![feature]` attrs for non-language (library) features.
|
|
pub declared_lib_features: Vec<(Symbol, Span)>,
|
|
$(
|
|
$(#[doc = $doc])*
|
|
pub $feature: bool
|
|
),+
|
|
}
|
|
|
|
impl Features {
|
|
pub fn walk_feature_fields(&self, mut f: impl FnMut(&str, bool)) {
|
|
$(f(stringify!($feature), self.$feature);)+
|
|
}
|
|
|
|
/// Is the given feature enabled?
|
|
///
|
|
/// Panics if the symbol doesn't correspond to a declared feature.
|
|
pub fn enabled(&self, feature: Symbol) -> bool {
|
|
match feature {
|
|
$( sym::$feature => self.$feature, )*
|
|
|
|
_ => panic!("`{}` was not listed in `declare_features`", feature),
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
impl Feature {
|
|
/// Sets this feature in `Features`. Panics if called on a non-active feature.
|
|
pub fn set(&self, features: &mut Features, span: Span) {
|
|
match self.state {
|
|
State::Active { set } => set(features, span),
|
|
_ => panic!("called `set` on feature `{}` which is not `active`", self.name),
|
|
}
|
|
}
|
|
}
|
|
|
|
// If you change this, please modify `src/doc/unstable-book` as well.
|
|
//
|
|
// Don't ever remove anything from this list; move them to `removed.rs`.
|
|
//
|
|
// The version numbers here correspond to the version in which the current status
|
|
// was set. This is most important for knowing when a particular feature became
|
|
// stable (active).
|
|
//
|
|
// Note that the features are grouped into internal/user-facing and then
|
|
// sorted by version inside those groups. This is enforced with tidy.
|
|
//
|
|
// N.B., `tools/tidy/src/features.rs` parses this information directly out of the
|
|
// source, so take care when modifying it.
|
|
|
|
#[rustfmt::skip]
|
|
declare_features! (
|
|
// -------------------------------------------------------------------------
|
|
// feature-group-start: internal feature gates
|
|
// -------------------------------------------------------------------------
|
|
|
|
// no-tracking-issue-start
|
|
|
|
/// Allows using `rustc_*` attributes (RFC 572).
|
|
(active, rustc_attrs, "1.0.0", None, None),
|
|
|
|
/// Allows using compiler's own crates.
|
|
(active, rustc_private, "1.0.0", Some(27812), None),
|
|
|
|
/// Allows using the `rust-intrinsic`'s "ABI".
|
|
(active, intrinsics, "1.0.0", None, None),
|
|
|
|
/// Allows using `#[lang = ".."]` attribute for linking items to special compiler logic.
|
|
(active, lang_items, "1.0.0", None, None),
|
|
|
|
/// Allows using the `#[stable]` and `#[unstable]` attributes.
|
|
(active, staged_api, "1.0.0", None, None),
|
|
|
|
/// Allows using `#[allow_internal_unstable]`. This is an
|
|
/// attribute on `macro_rules!` and can't use the attribute handling
|
|
/// below (it has to be checked before expansion possibly makes
|
|
/// macros disappear).
|
|
(active, allow_internal_unstable, "1.0.0", None, None),
|
|
|
|
/// Allows using `#[allow_internal_unsafe]`. This is an
|
|
/// attribute on `macro_rules!` and can't use the attribute handling
|
|
/// below (it has to be checked before expansion possibly makes
|
|
/// macros disappear).
|
|
(active, allow_internal_unsafe, "1.0.0", None, None),
|
|
|
|
/// no-tracking-issue-end
|
|
|
|
/// Allows using `#[link_name="llvm.*"]`.
|
|
(active, link_llvm_intrinsics, "1.0.0", Some(29602), None),
|
|
|
|
/// Allows using the `box $expr` syntax.
|
|
(active, box_syntax, "1.0.0", Some(49733), None),
|
|
|
|
/// Allows using `#[main]` to replace the entrypoint `#[lang = "start"]` calls.
|
|
(active, main, "1.0.0", Some(29634), None),
|
|
|
|
/// Allows using `#[start]` on a function indicating that it is the program entrypoint.
|
|
(active, start, "1.0.0", Some(29633), None),
|
|
|
|
/// Allows using the `#[fundamental]` attribute.
|
|
(active, fundamental, "1.0.0", Some(29635), None),
|
|
|
|
/// Allows using the `rust-call` ABI.
|
|
(active, unboxed_closures, "1.0.0", Some(29625), None),
|
|
|
|
/// Allows using the `#[linkage = ".."]` attribute.
|
|
(active, linkage, "1.0.0", Some(29603), None),
|
|
|
|
/// Allows features specific to OIBIT (auto traits).
|
|
(active, optin_builtin_traits, "1.0.0", Some(13231), None),
|
|
|
|
/// Allows using `box` in patterns (RFC 469).
|
|
(active, box_patterns, "1.0.0", Some(29641), None),
|
|
|
|
// no-tracking-issue-start
|
|
|
|
/// Allows using `#[prelude_import]` on glob `use` items.
|
|
(active, prelude_import, "1.2.0", None, None),
|
|
|
|
// no-tracking-issue-end
|
|
|
|
// no-tracking-issue-start
|
|
|
|
/// Allows using `#[omit_gdb_pretty_printer_section]`.
|
|
(active, omit_gdb_pretty_printer_section, "1.5.0", None, None),
|
|
|
|
/// Allows using the `vectorcall` ABI.
|
|
(active, abi_vectorcall, "1.7.0", None, None),
|
|
|
|
// no-tracking-issue-end
|
|
|
|
/// Allows using `#[structural_match]` which indicates that a type is structurally matchable.
|
|
/// FIXME: Subsumed by trait `StructuralPartialEq`, cannot move to removed until a library
|
|
/// feature with the same name exists.
|
|
(active, structural_match, "1.8.0", Some(31434), None),
|
|
|
|
/// Allows using the `may_dangle` attribute (RFC 1327).
|
|
(active, dropck_eyepatch, "1.10.0", Some(34761), None),
|
|
|
|
/// Allows using the `#![panic_runtime]` attribute.
|
|
(active, panic_runtime, "1.10.0", Some(32837), None),
|
|
|
|
/// Allows declaring with `#![needs_panic_runtime]` that a panic runtime is needed.
|
|
(active, needs_panic_runtime, "1.10.0", Some(32837), None),
|
|
|
|
// no-tracking-issue-start
|
|
|
|
/// Allows identifying the `compiler_builtins` crate.
|
|
(active, compiler_builtins, "1.13.0", None, None),
|
|
|
|
/// Allows using the `unadjusted` ABI; perma-unstable.
|
|
(active, abi_unadjusted, "1.16.0", None, None),
|
|
|
|
/// Used to identify crates that contain the profiler runtime.
|
|
(active, profiler_runtime, "1.18.0", None, None),
|
|
|
|
/// Allows using the `thiscall` ABI.
|
|
(active, abi_thiscall, "1.19.0", None, None),
|
|
|
|
/// Allows using `#![needs_allocator]`, an implementation detail of `#[global_allocator]`.
|
|
(active, allocator_internals, "1.20.0", None, None),
|
|
|
|
/// Added for testing E0705; perma-unstable.
|
|
(active, test_2018_feature, "1.31.0", None, Some(Edition::Edition2018)),
|
|
|
|
/// Allows `#[repr(no_niche)]` (an implementation detail of `rustc`,
|
|
/// it is not on path for eventual stabilization).
|
|
(active, no_niche, "1.42.0", None, None),
|
|
|
|
// no-tracking-issue-end
|
|
|
|
// -------------------------------------------------------------------------
|
|
// feature-group-end: internal feature gates
|
|
// -------------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------------
|
|
// feature-group-start: actual feature gates (target features)
|
|
// -------------------------------------------------------------------------
|
|
|
|
// FIXME: Document these and merge with the list below.
|
|
|
|
// Unstable `#[target_feature]` directives.
|
|
(active, arm_target_feature, "1.27.0", Some(44839), None),
|
|
(active, aarch64_target_feature, "1.27.0", Some(44839), None),
|
|
(active, hexagon_target_feature, "1.27.0", Some(44839), None),
|
|
(active, powerpc_target_feature, "1.27.0", Some(44839), None),
|
|
(active, mips_target_feature, "1.27.0", Some(44839), None),
|
|
(active, avx512_target_feature, "1.27.0", Some(44839), None),
|
|
(active, mmx_target_feature, "1.27.0", Some(44839), None),
|
|
(active, sse4a_target_feature, "1.27.0", Some(44839), None),
|
|
(active, tbm_target_feature, "1.27.0", Some(44839), None),
|
|
(active, wasm_target_feature, "1.30.0", Some(44839), None),
|
|
(active, adx_target_feature, "1.32.0", Some(44839), None),
|
|
(active, cmpxchg16b_target_feature, "1.32.0", Some(44839), None),
|
|
(active, movbe_target_feature, "1.34.0", Some(44839), None),
|
|
(active, rtm_target_feature, "1.35.0", Some(44839), None),
|
|
(active, f16c_target_feature, "1.36.0", Some(44839), None),
|
|
(active, riscv_target_feature, "1.45.0", Some(44839), None),
|
|
|
|
// -------------------------------------------------------------------------
|
|
// feature-group-end: actual feature gates (target features)
|
|
// -------------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------------
|
|
// feature-group-start: actual feature gates
|
|
// -------------------------------------------------------------------------
|
|
|
|
/// Allows using the `#[link_args]` attribute.
|
|
(active, link_args, "1.0.0", Some(29596), None),
|
|
|
|
/// Allows defining identifiers beyond ASCII.
|
|
(active, non_ascii_idents, "1.0.0", Some(55467), None),
|
|
|
|
/// Allows using `#[plugin_registrar]` on functions.
|
|
(active, plugin_registrar, "1.0.0", Some(29597), None),
|
|
|
|
/// Allows using `#![plugin(myplugin)]`.
|
|
(active, plugin, "1.0.0", Some(29597), None),
|
|
|
|
/// Allows using `#[thread_local]` on `static` items.
|
|
(active, thread_local, "1.0.0", Some(29594), None),
|
|
|
|
/// Allows the use of SIMD types in functions declared in `extern` blocks.
|
|
(active, simd_ffi, "1.0.0", Some(27731), None),
|
|
|
|
/// Allows using non lexical lifetimes (RFC 2094).
|
|
(active, nll, "1.0.0", Some(43234), None),
|
|
|
|
/// Allows the definition of `const` functions with some advanced features.
|
|
(active, const_fn, "1.2.0", Some(57563), None),
|
|
|
|
/// Allows associated type defaults.
|
|
(active, associated_type_defaults, "1.2.0", Some(29661), None),
|
|
|
|
/// Allows `#![no_core]`.
|
|
(active, no_core, "1.3.0", Some(29639), None),
|
|
|
|
/// Allows default type parameters to influence type inference.
|
|
(active, default_type_parameter_fallback, "1.3.0", Some(27336), None),
|
|
|
|
/// Allows `repr(simd)` and importing the various simd intrinsics.
|
|
(active, repr_simd, "1.4.0", Some(27731), None),
|
|
|
|
/// Allows `extern "platform-intrinsic" { ... }`.
|
|
(active, platform_intrinsics, "1.4.0", Some(27731), None),
|
|
|
|
/// Allows `#[unwind(..)]`.
|
|
///
|
|
/// Permits specifying whether a function should permit unwinding or abort on unwind.
|
|
(active, unwind_attributes, "1.4.0", Some(58760), None),
|
|
|
|
/// Allows attributes on expressions and non-item statements.
|
|
(active, stmt_expr_attributes, "1.6.0", Some(15701), None),
|
|
|
|
/// Allows the use of type ascription in expressions.
|
|
(active, type_ascription, "1.6.0", Some(23416), None),
|
|
|
|
/// Allows `cfg(target_thread_local)`.
|
|
(active, cfg_target_thread_local, "1.7.0", Some(29594), None),
|
|
|
|
/// Allows specialization of implementations (RFC 1210).
|
|
(active, specialization, "1.7.0", Some(31844), None),
|
|
|
|
/// A minimal, sound subset of specialization intended to be used by the
|
|
/// standard library until the soundness issues with specialization
|
|
/// are fixed.
|
|
(active, min_specialization, "1.7.0", Some(31844), None),
|
|
|
|
/// Allows using `#[naked]` on functions.
|
|
(active, naked_functions, "1.9.0", Some(32408), None),
|
|
|
|
/// Allows `cfg(target_has_atomic = "...")`.
|
|
(active, cfg_target_has_atomic, "1.9.0", Some(32976), None),
|
|
|
|
/// Allows `X..Y` patterns.
|
|
(active, exclusive_range_pattern, "1.11.0", Some(37854), None),
|
|
|
|
/// Allows the `!` type. Does not imply 'exhaustive_patterns' (below) any more.
|
|
(active, never_type, "1.13.0", Some(35121), None),
|
|
|
|
/// Allows exhaustive pattern matching on types that contain uninhabited types.
|
|
(active, exhaustive_patterns, "1.13.0", Some(51085), None),
|
|
|
|
/// Allows `union`s to implement `Drop`. Moreover, `union`s may now include fields
|
|
/// that don't implement `Copy` as long as they don't have any drop glue.
|
|
/// This is checked recursively. On encountering type variable where no progress can be made,
|
|
/// `T: Copy` is used as a substitute for "no drop glue".
|
|
///
|
|
/// NOTE: A limited form of `union U { ... }` was accepted in 1.19.0.
|
|
(active, untagged_unions, "1.13.0", Some(55149), None),
|
|
|
|
/// Allows `#[link(..., cfg(..))]`.
|
|
(active, link_cfg, "1.14.0", Some(37406), None),
|
|
|
|
/// Allows `extern "ptx-*" fn()`.
|
|
(active, abi_ptx, "1.15.0", Some(38788), None),
|
|
|
|
/// Allows the `#[repr(i128)]` attribute for enums.
|
|
(active, repr128, "1.16.0", Some(56071), None),
|
|
|
|
/// Allows `#[link(kind="static-nobundle"...)]`.
|
|
(active, static_nobundle, "1.16.0", Some(37403), None),
|
|
|
|
/// Allows `extern "msp430-interrupt" fn()`.
|
|
(active, abi_msp430_interrupt, "1.16.0", Some(38487), None),
|
|
|
|
/// Allows declarative macros 2.0 (`macro`).
|
|
(active, decl_macro, "1.17.0", Some(39412), None),
|
|
|
|
/// Allows `extern "x86-interrupt" fn()`.
|
|
(active, abi_x86_interrupt, "1.17.0", Some(40180), None),
|
|
|
|
/// Allows a test to fail without failing the whole suite.
|
|
(active, allow_fail, "1.19.0", Some(46488), None),
|
|
|
|
/// Allows unsized tuple coercion.
|
|
(active, unsized_tuple_coercion, "1.20.0", Some(42877), None),
|
|
|
|
/// Allows defining generators.
|
|
(active, generators, "1.21.0", Some(43122), None),
|
|
|
|
/// Allows `#[doc(cfg(...))]`.
|
|
(active, doc_cfg, "1.21.0", Some(43781), None),
|
|
|
|
/// Allows `#[doc(masked)]`.
|
|
(active, doc_masked, "1.21.0", Some(44027), None),
|
|
|
|
/// Allows `#[doc(include = "some-file")]`.
|
|
(active, external_doc, "1.22.0", Some(44732), None),
|
|
|
|
/// Allows using `crate` as visibility modifier, synonymous with `pub(crate)`.
|
|
(active, crate_visibility_modifier, "1.23.0", Some(53120), None),
|
|
|
|
/// Allows defining `extern type`s.
|
|
(active, extern_types, "1.23.0", Some(43467), None),
|
|
|
|
/// Allows trait methods with arbitrary self types.
|
|
(active, arbitrary_self_types, "1.23.0", Some(44874), None),
|
|
|
|
/// Allows in-band quantification of lifetime bindings (e.g., `fn foo(x: &'a u8) -> &'a u8`).
|
|
(active, in_band_lifetimes, "1.23.0", Some(44524), None),
|
|
|
|
/// Allows associated types to be generic, e.g., `type Foo<T>;` (RFC 1598).
|
|
(active, generic_associated_types, "1.23.0", Some(44265), None),
|
|
|
|
/// Allows defining `trait X = A + B;` alias items.
|
|
(active, trait_alias, "1.24.0", Some(41517), None),
|
|
|
|
/// Allows inferring `'static` outlives requirements (RFC 2093).
|
|
(active, infer_static_outlives_requirements, "1.26.0", Some(54185), None),
|
|
|
|
/// Allows accessing fields of unions inside `const` functions.
|
|
(active, const_fn_union, "1.27.0", Some(51909), None),
|
|
|
|
/// Allows casting raw pointers to `usize` during const eval.
|
|
(active, const_raw_ptr_to_usize_cast, "1.27.0", Some(51910), None),
|
|
|
|
/// Allows dereferencing raw pointers during const eval.
|
|
(active, const_raw_ptr_deref, "1.27.0", Some(51911), None),
|
|
|
|
/// Allows comparing raw pointers during const eval.
|
|
(active, const_compare_raw_pointers, "1.27.0", Some(53020), None),
|
|
|
|
/// Allows `#[doc(alias = "...")]`.
|
|
(active, doc_alias, "1.27.0", Some(50146), None),
|
|
|
|
/// Allows inconsistent bounds in where clauses.
|
|
(active, trivial_bounds, "1.28.0", Some(48214), None),
|
|
|
|
/// Allows `'a: { break 'a; }`.
|
|
(active, label_break_value, "1.28.0", Some(48594), None),
|
|
|
|
/// Allows using `#[doc(keyword = "...")]`.
|
|
(active, doc_keyword, "1.28.0", Some(51315), None),
|
|
|
|
/// Allows using `try {...}` expressions.
|
|
(active, try_blocks, "1.29.0", Some(31436), None),
|
|
|
|
/// Allows defining an `#[alloc_error_handler]`.
|
|
(active, alloc_error_handler, "1.29.0", Some(51540), None),
|
|
|
|
/// Allows using the `amdgpu-kernel` ABI.
|
|
(active, abi_amdgpu_kernel, "1.29.0", Some(51575), None),
|
|
|
|
/// Allows panicking during const eval (producing compile-time errors).
|
|
(active, const_panic, "1.30.0", Some(51999), None),
|
|
|
|
/// Allows `#[marker]` on certain traits allowing overlapping implementations.
|
|
(active, marker_trait_attr, "1.30.0", Some(29864), None),
|
|
|
|
/// Allows macro attributes on expressions, statements and non-inline modules.
|
|
(active, proc_macro_hygiene, "1.30.0", Some(54727), None),
|
|
|
|
/// Allows unsized rvalues at arguments and parameters.
|
|
(active, unsized_locals, "1.30.0", Some(48055), None),
|
|
|
|
/// Allows custom test frameworks with `#![test_runner]` and `#[test_case]`.
|
|
(active, custom_test_frameworks, "1.30.0", Some(50297), None),
|
|
|
|
/// Allows non-builtin attributes in inner attribute position.
|
|
(active, custom_inner_attributes, "1.30.0", Some(54726), None),
|
|
|
|
/// Allows `impl Trait` in bindings (`let`, `const`, `static`).
|
|
(active, impl_trait_in_bindings, "1.30.0", Some(63065), None),
|
|
|
|
/// Allows using `reason` in lint attributes and the `#[expect(lint)]` lint check.
|
|
(active, lint_reasons, "1.31.0", Some(54503), None),
|
|
|
|
/// Allows exhaustive integer pattern matching on `usize` and `isize`.
|
|
(active, precise_pointer_size_matching, "1.32.0", Some(56354), None),
|
|
|
|
/// Allows using `#[ffi_returns_twice]` on foreign functions.
|
|
(active, ffi_returns_twice, "1.34.0", Some(58314), None),
|
|
|
|
/// Allows const generic types (e.g. `struct Foo<const N: usize>(...);`).
|
|
(active, const_generics, "1.34.0", Some(44580), None),
|
|
|
|
/// Allows using `#[optimize(X)]`.
|
|
(active, optimize_attribute, "1.34.0", Some(54882), None),
|
|
|
|
/// Allows using C-variadics.
|
|
(active, c_variadic, "1.34.0", Some(44930), None),
|
|
|
|
/// Allows the user of associated type bounds.
|
|
(active, associated_type_bounds, "1.34.0", Some(52662), None),
|
|
|
|
/// Allows `if/while p && let q = r && ...` chains.
|
|
(active, let_chains, "1.37.0", Some(53667), None),
|
|
|
|
/// Allows #[repr(transparent)] on unions (RFC 2645).
|
|
(active, transparent_unions, "1.37.0", Some(60405), None),
|
|
|
|
/// Allows explicit discriminants on non-unit enum variants.
|
|
(active, arbitrary_enum_discriminant, "1.37.0", Some(60553), None),
|
|
|
|
/// Allows `impl Trait` with multiple unrelated lifetimes.
|
|
(active, member_constraints, "1.37.0", Some(61997), None),
|
|
|
|
/// Allows `async || body` closures.
|
|
(active, async_closure, "1.37.0", Some(62290), None),
|
|
|
|
/// Allows `[x; N]` where `x` is a constant (RFC 2203).
|
|
(active, const_in_array_repeat_expressions, "1.37.0", Some(49147), None),
|
|
|
|
/// Allows `impl Trait` to be used inside type aliases (RFC 2515).
|
|
(active, type_alias_impl_trait, "1.38.0", Some(63063), None),
|
|
|
|
/// Allows the use of or-patterns (e.g., `0 | 1`).
|
|
(active, or_patterns, "1.38.0", Some(54883), None),
|
|
|
|
/// Allows the definition of `const extern fn` and `const unsafe extern fn`.
|
|
(active, const_extern_fn, "1.40.0", Some(64926), None),
|
|
|
|
/// Allows the use of raw-dylibs (RFC 2627).
|
|
(active, raw_dylib, "1.40.0", Some(58713), None),
|
|
|
|
/// Allows `#[track_caller]` to be used which provides
|
|
/// accurate caller location reporting during panic (RFC 2091).
|
|
(active, track_caller, "1.40.0", Some(47809), None),
|
|
|
|
/// Allows making `dyn Trait` well-formed even if `Trait` is not object safe.
|
|
/// In that case, `dyn Trait: Trait` does not hold. Moreover, coercions and
|
|
/// casts in safe Rust to `dyn Trait` for such a `Trait` is also forbidden.
|
|
(active, object_safe_for_dispatch, "1.40.0", Some(43561), None),
|
|
|
|
/// Allows using the `efiapi` ABI.
|
|
(active, abi_efiapi, "1.40.0", Some(65815), None),
|
|
|
|
/// Allows `&raw const $place_expr` and `&raw mut $place_expr` expressions.
|
|
(active, raw_ref_op, "1.41.0", Some(64490), None),
|
|
|
|
/// Allows diverging expressions to fall back to `!` rather than `()`.
|
|
(active, never_type_fallback, "1.41.0", Some(65992), None),
|
|
|
|
/// Allows using the `#[register_attr]` attribute.
|
|
(active, register_attr, "1.41.0", Some(66080), None),
|
|
|
|
/// Allows using the `#[register_tool]` attribute.
|
|
(active, register_tool, "1.41.0", Some(66079), None),
|
|
|
|
/// Allows the use of `if` and `match` in constants.
|
|
(active, const_if_match, "1.41.0", Some(49146), None),
|
|
|
|
/// Allows the use of `#[cfg(sanitize = "option")]`; set when -Zsanitizer is used.
|
|
(active, cfg_sanitize, "1.41.0", Some(39699), None),
|
|
|
|
/// Allows using `..X`, `..=X`, `...X`, and `X..` as a pattern.
|
|
(active, half_open_range_patterns, "1.41.0", Some(67264), None),
|
|
|
|
/// Allows using `&mut` in constant functions.
|
|
(active, const_mut_refs, "1.41.0", Some(57349), None),
|
|
|
|
/// Allows the use of `loop` and `while` in constants.
|
|
(active, const_loop, "1.41.0", Some(52000), None),
|
|
|
|
/// Allows bindings in the subpattern of a binding pattern.
|
|
/// For example, you can write `x @ Some(y)`.
|
|
(active, bindings_after_at, "1.41.0", Some(65490), None),
|
|
|
|
/// Allows patterns with concurrent by-move and by-ref bindings.
|
|
/// For example, you can write `Foo(a, ref b)` where `a` is by-move and `b` is by-ref.
|
|
(active, move_ref_pattern, "1.42.0", Some(68354), None),
|
|
|
|
/// Allows `impl const Trait for T` syntax.
|
|
(active, const_trait_impl, "1.42.0", Some(67792), None),
|
|
|
|
/// Allows `T: ?const Trait` syntax in bounds.
|
|
(active, const_trait_bound_opt_out, "1.42.0", Some(67794), None),
|
|
|
|
/// Allows the use of `no_sanitize` attribute.
|
|
(active, no_sanitize, "1.42.0", Some(39699), None),
|
|
|
|
// Allows limiting the evaluation steps of const expressions
|
|
(active, const_eval_limit, "1.43.0", Some(67217), None),
|
|
|
|
/// Allow negative trait implementations.
|
|
(active, negative_impls, "1.44.0", Some(68318), None),
|
|
|
|
/// Allows the use of `#[target_feature]` on safe functions.
|
|
(active, target_feature_11, "1.45.0", Some(69098), None),
|
|
|
|
/// Allow conditional compilation depending on rust version
|
|
(active, cfg_version, "1.45.0", Some(64796), None),
|
|
|
|
// -------------------------------------------------------------------------
|
|
// feature-group-end: actual feature gates
|
|
// -------------------------------------------------------------------------
|
|
);
|
|
|
|
/// Some features are known to be incomplete and using them is likely to have
|
|
/// unanticipated results, such as compiler crashes. We warn the user about these
|
|
/// to alert them.
|
|
pub const INCOMPLETE_FEATURES: &[Symbol] = &[
|
|
sym::impl_trait_in_bindings,
|
|
sym::generic_associated_types,
|
|
sym::const_generics,
|
|
sym::let_chains,
|
|
sym::raw_dylib,
|
|
sym::const_trait_impl,
|
|
sym::const_trait_bound_opt_out,
|
|
];
|