diff --git a/compiler/rustc_abi/src/extern_abi.rs b/compiler/rustc_abi/src/extern_abi.rs index 91c0bc0b59bca..ba7a1636e356c 100644 --- a/compiler/rustc_abi/src/extern_abi.rs +++ b/compiler/rustc_abi/src/extern_abi.rs @@ -241,11 +241,25 @@ impl PartialEq for ExternAbi { impl Eq for ExternAbi {} +impl ExternAbi { + /// Common implementation for `Hash` and `StableHash`. + fn stable_hash_inner(&self, hasher: &mut impl Hasher) { + // To avoid staging inconsistencies in stable hashing, we must not rely + // on any stdlib-provided or stdlib-derived impl of `Hash`. + // See for context. + + // Hardcoded copy of the unstable `Hasher::write_str`, with an explicit terminator. + hasher.write(self.as_str().as_bytes()); + hasher.write_u8(0xFF); + + // double-assurance of a prefix breaker + hasher.write_u32(u32::from_be_bytes(*b"ABI\0")); + } +} + impl Hash for ExternAbi { fn hash(&self, state: &mut H) { - self.as_str().hash(state); - // double-assurance of a prefix breaker - u32::from_be_bytes(*b"ABI\0").hash(state); + self.stable_hash_inner(state); } } @@ -253,7 +267,7 @@ impl Hash for ExternAbi { impl StableHash for ExternAbi { #[inline] fn stable_hash(&self, _: &mut Hcx, hasher: &mut StableHasher) { - Hash::hash(self, hasher); + self.stable_hash_inner(hasher); } } diff --git a/compiler/rustc_arena/src/lib.rs b/compiler/rustc_arena/src/lib.rs index 4c9258b753d8f..c7d53d2659fd3 100644 --- a/compiler/rustc_arena/src/lib.rs +++ b/compiler/rustc_arena/src/lib.rs @@ -10,7 +10,6 @@ // tidy-alphabetical-start #![allow(clippy::mut_from_ref)] // Arena allocators are one place where this pattern is fine. #![allow(internal_features)] -#![cfg_attr(bootstrap, feature(unwrap_infallible))] #![cfg_attr(test, feature(test))] #![deny(unsafe_op_in_unsafe_fn)] #![doc(test(no_crate_inject, attr(deny(warnings))))] diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs index 862d4736ca33c..89105722f6c8e 100644 --- a/compiler/rustc_ast_passes/src/feature_gate.rs +++ b/compiler/rustc_ast_passes/src/feature_gate.rs @@ -241,12 +241,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { // Function pointers cannot be `const` self.check_late_bound_lifetime_defs(&fn_ptr_ty.generic_params); } - ast::TyKind::Pat(..) => { - gate!(self, pattern_types, ty.span, "pattern types are unstable"); - } - ast::TyKind::View(..) => { - gate!(self, view_types, ty.span, "view types are unstable"); - } _ => {} } visit::walk_ty(self, ty) @@ -469,7 +463,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) { gate_all!(unnamed_enum_variants, "unnamed enum variants are experimental"); gate_all!(unsafe_binders, "unsafe binder types are experimental"); gate_all!(unsafe_fields, "`unsafe` fields are experimental"); - gate_all!(view_types, "view types are experimental"); gate_all!(where_clause_attrs, "attributes in `where` clause are unstable"); gate_all!(yeet_expr, "`do yeet` expression is experimental"); // tidy-alphabetical-end diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs index a5dbaf81376c1..36096cb09eb1b 100644 --- a/compiler/rustc_ast_pretty/src/pprust/state.rs +++ b/compiler/rustc_ast_pretty/src/pprust/state.rs @@ -1437,9 +1437,12 @@ impl<'a> State<'a> { self.word("..."); } ast::TyKind::Pat(ty, pat) => { + self.word("k#pattern_type"); + self.popen(); self.print_type(ty); self.word(" is "); self.print_ty_pat(pat); + self.pclose(); } ast::TyKind::FieldOf(ty, variant, field) => { self.word("k#field_of"); @@ -1459,8 +1462,11 @@ impl<'a> State<'a> { self.pclose(); } ast::TyKind::View(ty, fields) => { + self.word("k#view_type"); + self.popen(); self.print_type(ty); self.print_view(fields); + self.pclose(); } ast::TyKind::GcaMacro(expr) => { self.word_nbsp("core::gca!"); diff --git a/compiler/rustc_ast_pretty/src/pprust/tests.rs b/compiler/rustc_ast_pretty/src/pprust/tests.rs index 43bb68216d929..1a5a518ee41e0 100644 --- a/compiler/rustc_ast_pretty/src/pprust/tests.rs +++ b/compiler/rustc_ast_pretty/src/pprust/tests.rs @@ -80,6 +80,6 @@ fn test_field_view() { }; let ty_str = ty_to_string(&ty); - assert_eq!(ty_str, "(/*DUMMY*/).{ milhouse, apu }"); + assert_eq!(ty_str, "k#view_type((/*DUMMY*/).{ milhouse, apu })"); }); } diff --git a/compiler/rustc_attr_ir/src/lang_items.rs b/compiler/rustc_attr_ir/src/lang_items.rs index 475d645b65fb3..648ed0daa146c 100644 --- a/compiler/rustc_attr_ir/src/lang_items.rs +++ b/compiler/rustc_attr_ir/src/lang_items.rs @@ -8,7 +8,6 @@ //! * Functions called by the compiler itself. use rustc_data_structures::fx::FxIndexMap; -use rustc_data_structures::stable_hash::{StableHash, StableHashCtxt, StableHasher}; use rustc_macros::{BlobDecodable, Encodable, PrintAttribute, StableHash}; use rustc_span::def_id::DefId; use rustc_span::{Symbol, kw, sym}; @@ -80,7 +79,7 @@ macro_rules! language_item_table { $( $(#[$attr:meta])* $variant:ident, $module:ident :: $name:ident, $method:ident, $target:expr, $generics:expr; )* ) => { /// A representation of all the valid lang items in Rust. - #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Encodable, BlobDecodable, PrintAttribute)] + #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, StableHash, Encodable, BlobDecodable, PrintAttribute)] pub enum LangItem { $( #[doc = concat!("The `", stringify!($name), "` lang item.")] @@ -149,12 +148,6 @@ macro_rules! language_item_table { } } -impl StableHash for LangItem { - fn stable_hash(&self, _: &mut Hcx, hasher: &mut StableHasher) { - ::std::hash::Hash::hash(self, hasher); - } -} - language_item_table! { // Variant name, Name, Getter method name, Target Generic requirements; Sized, sym::sized, sized_trait, Target::Trait, GenericRequirement::Exact(0); @@ -187,7 +180,9 @@ language_item_table! { UnsafeUnpin, sym::unsafe_unpin, unsafe_unpin_trait, Target::Trait, GenericRequirement::Exact(0); FnPtrTrait, sym::fn_ptr_trait, fn_ptr_trait, Target::Trait, GenericRequirement::Exact(0); - FnPtrAsPtr, sym::fn_ptr_as_ptr, fn_ptr_as_ptr, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None; + FnAddrTrait, sym::fn_addr_trait, fn_addr_trait, Target::Trait, GenericRequirement::Exact(0); + FnAddrAsPtr, sym::fn_addr_as_ptr, fn_addr_as_ptr, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None; + FnAddrAddrFn, sym::fn_addr_addr_fn, fn_addr_addr_fn, Target::Method(MethodKind::Trait { body: true }), GenericRequirement::None; FnPtrFromPtr, sym::fn_ptr_from_ptr, fn_ptr_from_ptr, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None; Code, sym::code, code, Target::ForeignTy, GenericRequirement::None; diff --git a/compiler/rustc_builtin_macros/src/diagnostics.rs b/compiler/rustc_builtin_macros/src/diagnostics.rs index 30c332109df5c..851317cde7f4e 100644 --- a/compiler/rustc_builtin_macros/src/diagnostics.rs +++ b/compiler/rustc_builtin_macros/src/diagnostics.rs @@ -229,6 +229,13 @@ mod autodiff { } } +#[derive(Diagnostic)] +#[diag("offload_kernel must be applied to function")] +pub(crate) struct OffloadKernelInvalidApplication { + #[primary_span] + pub(crate) span: Span, +} + #[derive(Diagnostic)] #[diag("cannot concatenate {$lit_kind} literals")] pub(crate) struct ConcatBytesInvalid { diff --git a/compiler/rustc_builtin_macros/src/lib.rs b/compiler/rustc_builtin_macros/src/lib.rs index f1e7846f54f9b..b2089f9b4567a 100644 --- a/compiler/rustc_builtin_macros/src/lib.rs +++ b/compiler/rustc_builtin_macros/src/lib.rs @@ -45,13 +45,11 @@ mod global_allocator; mod iter; mod log_syntax; mod offload; -mod pattern_type; mod rustdoc_skip_body; mod source_util; mod test; mod test_binder_constraints; mod trace_macros; -mod view_type; pub mod asm; pub mod cmdline_attrs; @@ -100,13 +98,11 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) { module_path: source_util::expand_mod, naked_asm: asm::expand_naked_asm, option_env: env::expand_option_env, - pattern_type: pattern_type::expand, std_panic: edition_panic::expand_panic, stringify: source_util::expand_stringify, test_binder_constraints: test_binder_constraints::expand, trace_macros: trace_macros::expand_trace_macros, unreachable: edition_panic::expand_unreachable, - view_type: view_type::expand, // tidy-alphabetical-end } diff --git a/compiler/rustc_builtin_macros/src/offload.rs b/compiler/rustc_builtin_macros/src/offload.rs index ef38382c48319..e5076978f7cd1 100644 --- a/compiler/rustc_builtin_macros/src/offload.rs +++ b/compiler/rustc_builtin_macros/src/offload.rs @@ -21,14 +21,26 @@ fn outer_normal_attr(normal: &Box, id: ast::AttrId, span: Span) fn extract_fn( item: &Annotatable, ) -> Option<(ast::Visibility, ast::FnSig, Ident, ast::Generics, Option>)> { - match item { - Annotatable::Item(iitem) => match &iitem.kind { - ast::ItemKind::Fn(ast::Fn { sig, ident, generics, body, .. }) => { - Some((iitem.vis.clone(), sig.clone(), *ident, generics.clone(), body.clone())) - } - _ => None, - }, + let fn_item_kind_and_vis = match item { + Annotatable::Item(iitem) => Some((&iitem.kind, &iitem.vis)), + Annotatable::Stmt(stmt) if let ast::StmtKind::Item(iitem) = &stmt.kind => { + Some((&iitem.kind, &iitem.vis)) + } _ => None, + }; + + if let Some((item_kind, visibility)) = fn_item_kind_and_vis + && let ast::ItemKind::Fn(kind) = item_kind + { + Some(( + visibility.clone(), + kind.sig.clone(), + kind.ident, + kind.generics.clone(), + kind.body.clone(), + )) + } else { + None } } @@ -68,7 +80,7 @@ pub(crate) fn expand_kernel( let dcx = ecx.sess.dcx(); let Some((vis, sig, ident, generics, body)) = extract_fn(&item) else { - dcx.emit_err(diagnostics::AutoDiffInvalidApplication { span: item.span() }); + dcx.emit_err(diagnostics::OffloadKernelInvalidApplication { span: item.span() }); return vec![item]; }; @@ -100,10 +112,19 @@ pub(crate) fn expand_kernel( ); let device_item = { - let mut item = + let mut device_item_ecx = ecx.item(span, thin_vec![rustc_offload_kernel.clone()], ast::ItemKind::Fn(device_fn)); - item.vis = vis.clone(); - Annotatable::Item(item) + device_item_ecx.vis = vis.clone(); + + match &item { + Annotatable::Item(_) => Annotatable::Item(device_item_ecx), + Annotatable::Stmt(_) => { + Annotatable::Stmt(Box::new(ecx.stmt_item(span, device_item_ecx))) + } + _ => { + unreachable!("item kind checked previously") + } + } }; // unimplemented! body @@ -150,13 +171,20 @@ pub(crate) fn expand_kernel( let inline_never = outer_normal_attr(&inline_never_attr, new_id, span); let host_item = { - let mut item = ecx.item( + let mut host_item_ecx = ecx.item( span, thin_vec![rustc_offload_kernel, inline_never], ast::ItemKind::Fn(host_fn), ); - item.vis = vis; - Annotatable::Item(item) + host_item_ecx.vis = vis; + + match &item { + Annotatable::Item(_) => Annotatable::Item(host_item_ecx), + Annotatable::Stmt(_) => Annotatable::Stmt(Box::new(ecx.stmt_item(span, host_item_ecx))), + _ => { + unreachable!("item kind checked previously") + } + } }; if compile_for_device(ecx) { vec![device_item] } else { vec![host_item] } diff --git a/compiler/rustc_builtin_macros/src/pattern_type.rs b/compiler/rustc_builtin_macros/src/pattern_type.rs deleted file mode 100644 index 4d34ba963e4e8..0000000000000 --- a/compiler/rustc_builtin_macros/src/pattern_type.rs +++ /dev/null @@ -1,75 +0,0 @@ -use rustc_ast::tokenstream::TokenStream; -use rustc_ast::{AnonConst, DUMMY_NODE_ID, Ty, TyPat, TyPatKind, ast, token}; -use rustc_errors::PResult; -use rustc_expand::base::{self, DummyResult, ExpandResult, ExtCtxt, MacroExpanderResult}; -use rustc_parse::exp; -use rustc_parse::parser::{CommaRecoveryMode, RecoverColon, RecoverComma}; -use rustc_span::Span; - -pub(crate) fn expand<'cx>( - cx: &'cx mut ExtCtxt<'_>, - sp: Span, - tts: TokenStream, -) -> MacroExpanderResult<'cx> { - let (ty, pat) = match parse_pat_ty(cx, tts) { - Ok(parsed) => parsed, - Err(err) => { - return ExpandResult::Ready(DummyResult::any(sp, err.emit_err())); - } - }; - - ExpandResult::Ready(base::MacEager::ty(cx.ty(sp, ast::TyKind::Pat(ty, pat)))) -} - -fn parse_pat_ty<'a>( - cx: &mut ExtCtxt<'a>, - stream: TokenStream, -) -> PResult<'a, (Box, Box)> { - let mut parser = cx.new_parser_from_tts(stream); - - let ty = parser.parse_ty()?; - parser.expect_keyword(exp!(Is))?; - - let start = parser.token.span; - let pat = if parser.eat(exp!(Bang)) { - parser.expect_keyword(exp!(Null))?; - ty_pat(TyPatKind::NotNull, start.to(parser.token.span)) - } else { - pat_to_ty_pat( - cx, - parser.parse_pat_no_top_guard( - None, - RecoverComma::No, - RecoverColon::No, - CommaRecoveryMode::EitherTupleOrPipe, - )?, - ) - }; - - if parser.token != token::Eof { - parser.unexpected()?; - } - - Ok((ty, Box::new(pat))) -} - -fn ty_pat(kind: TyPatKind, span: Span) -> TyPat { - TyPat { id: DUMMY_NODE_ID, kind, span } -} - -fn pat_to_ty_pat(cx: &mut ExtCtxt<'_>, pat: ast::Pat) -> TyPat { - let kind = match pat.kind { - ast::PatKind::Range(start, end, include_end) => TyPatKind::Range( - start.map(|value| Box::new(AnonConst { id: DUMMY_NODE_ID, value })), - end.map(|value| Box::new(AnonConst { id: DUMMY_NODE_ID, value })), - include_end, - ), - ast::PatKind::Or(variants) => { - TyPatKind::Or(variants.into_iter().map(|pat| pat_to_ty_pat(cx, pat)).collect()) - } - ast::PatKind::Err(guar) => TyPatKind::Err(guar), - ast::PatKind::Paren(p) => pat_to_ty_pat(cx, *p).kind, - _ => TyPatKind::Err(cx.dcx().span_err(pat.span, "pattern not supported in pattern types")), - }; - ty_pat(kind, pat.span) -} diff --git a/compiler/rustc_builtin_macros/src/view_type.rs b/compiler/rustc_builtin_macros/src/view_type.rs deleted file mode 100644 index 69bd8f2727fc3..0000000000000 --- a/compiler/rustc_builtin_macros/src/view_type.rs +++ /dev/null @@ -1,47 +0,0 @@ -use rustc_ast::token::TokenKind; -use rustc_ast::tokenstream::TokenStream; -use rustc_ast::{Ty, ast}; -use rustc_errors::PResult; -use rustc_expand::base::{self, DummyResult, ExpandResult, ExtCtxt, MacroExpanderResult}; -use rustc_parse::parser::{ExpTokenPair, TokenType}; -use rustc_span::{Ident, Span}; -use thin_vec::ThinVec; - -pub(crate) fn expand<'cx>( - cx: &'cx mut ExtCtxt<'_>, - sp: Span, - tts: TokenStream, -) -> MacroExpanderResult<'cx> { - let (ty, pat) = match parse_view_ty(cx, tts) { - Ok(parsed) => parsed, - Err(err) => { - return ExpandResult::Ready(DummyResult::any(sp, err.emit_err())); - } - }; - - ExpandResult::Ready(base::MacEager::ty(cx.ty(sp, ast::TyKind::View(ty, pat)))) -} - -fn parse_view_ty<'a>( - cx: &mut ExtCtxt<'a>, - stream: TokenStream, -) -> PResult<'a, (Box, ThinVec)> { - let mut parser = cx.new_parser_from_tts(stream); - - let ty = parser.parse_ty()?; - - parser.expect(ExpTokenPair { tok: TokenKind::Dot, token_type: TokenType::Dot })?; - - let fields = match parser.parse_delim_comma_seq( - ExpTokenPair { tok: TokenKind::OpenBrace, token_type: TokenType::OpenBrace }, - ExpTokenPair { tok: TokenKind::CloseBrace, token_type: TokenType::CloseBrace }, - |p| p.parse_field_name(), - ) { - Ok((fields, _)) => fields, - Err(diag) => { - return Err(diag); - } - }; - - Ok((ty, fields)) -} diff --git a/compiler/rustc_codegen_cranelift/example/mini_core.rs b/compiler/rustc_codegen_cranelift/example/mini_core.rs index d6d82a9d2af69..3c9f6bdddc129 100644 --- a/compiler/rustc_codegen_cranelift/example/mini_core.rs +++ b/compiler/rustc_codegen_cranelift/example/mini_core.rs @@ -6,9 +6,10 @@ extern_types, decl_macro, rustc_attrs, + allow_internal_unstable, + forced_keywords, rustc_private, transparent_unions, - pattern_types, auto_traits, freeze_impls )] @@ -591,12 +592,9 @@ pub trait Deref { fn deref(&self) -> &Self::Target; } -#[rustc_builtin_macro(pattern_type)] -#[macro_export] -macro_rules! pattern_type { - ($($arg:tt)*) => { - /* compiler built-in */ - }; +#[allow_internal_unstable(internal_syntax)] +pub macro pattern_type($($arg:tt)*) { + k#pattern_type($($arg)*) } impl CoerceUnsized for pattern_type!(*const T is !null) where diff --git a/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs b/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs index c53ec2ec6710d..2db42f3bd5930 100644 --- a/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs +++ b/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs @@ -1,12 +1,4 @@ -#![feature( - no_core, - lang_items, - extern_types, - thread_local, - repr_simd, - pattern_types, - rustc_private -)] +#![feature(no_core, lang_items, extern_types, thread_local, repr_simd, rustc_private)] #![cfg_attr(not(any(jit, target_vendor = "apple", windows)), feature(linkage))] #![no_core] #![allow(dead_code, non_camel_case_types, internal_features)] diff --git a/compiler/rustc_codegen_gcc/build_system/src/test.rs b/compiler/rustc_codegen_gcc/build_system/src/test.rs index fe36adba0587e..5ae6d5fee5770 100644 --- a/compiler/rustc_codegen_gcc/build_system/src/test.rs +++ b/compiler/rustc_codegen_gcc/build_system/src/test.rs @@ -247,6 +247,8 @@ fn mini_tests(env: &Env, args: &TestArg) -> Result<(), String> { &"mini_core", &"--crate-type", &crate_types, + &"--edition", + &"2024", &"--target", &args.config_info.target_triple, ]); diff --git a/compiler/rustc_codegen_gcc/example/mini_core.rs b/compiler/rustc_codegen_gcc/example/mini_core.rs index 383fbfc678922..e5e8f6042e4a2 100644 --- a/compiler/rustc_codegen_gcc/example/mini_core.rs +++ b/compiler/rustc_codegen_gcc/example/mini_core.rs @@ -6,10 +6,11 @@ extern_types, decl_macro, rustc_attrs, + allow_internal_unstable, + forced_keywords, transparent_unions, auto_traits, freeze_impls, - pattern_types, thread_local, rustc_private )] @@ -40,9 +41,9 @@ unsafe extern "C" { type VTable; } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn _Unwind_Resume() { - intrinsics::unreachable(); + unsafe { intrinsics::unreachable(); } } #[lang = "pointee_sized"] @@ -607,12 +608,9 @@ impl Allocator for Global {} #[rustc_nonnull_optimization_guaranteed] pub struct NonNull(pub pattern_type!(*const T is !null)); -#[rustc_builtin_macro(pattern_type)] -#[macro_export] -macro_rules! pattern_type { - ($($arg:tt)*) => { - /* compiler built-in */ - }; +#[allow_internal_unstable(internal_syntax)] +pub macro pattern_type($($arg:tt)*) { + k#pattern_type($($arg)*) } impl CoerceUnsized for pattern_type!(*const T is !null) where @@ -703,11 +701,11 @@ pub mod intrinsics { #[rustc_intrinsic] pub const fn size_of() -> usize; #[rustc_intrinsic] - pub unsafe fn size_of_val(val: *const T) -> usize; + pub unsafe fn size_of_val(val: *const T) -> usize; #[rustc_intrinsic] pub const fn align_of() -> usize; #[rustc_intrinsic] - pub unsafe fn align_of_val(val: *const T) -> usize; + pub unsafe fn align_of_val(val: *const T) -> usize; #[rustc_intrinsic] pub unsafe fn copy(src: *const T, dst: *mut T, count: usize); #[rustc_intrinsic] @@ -715,7 +713,7 @@ pub mod intrinsics { #[rustc_intrinsic] pub unsafe fn ctlz_nonzero(x: T) -> u32; #[rustc_intrinsic] - pub const fn needs_drop() -> bool; + pub const fn needs_drop() -> bool; #[rustc_intrinsic] pub fn bitreverse(x: T) -> T; #[rustc_intrinsic] @@ -728,7 +726,7 @@ pub mod intrinsics { pub mod libc { #[link(name = "c")] - extern "C" { + unsafe extern "C" { pub fn puts(s: *const u8) -> i32; pub fn printf(format: *const i8, ...) -> i32; pub fn malloc(size: usize) -> *mut u8; @@ -783,7 +781,7 @@ impl Index for [T] { } } -extern "C" { +unsafe extern "C" { type VaListImpl; } @@ -824,7 +822,7 @@ struct PanicLocation { column: u32, } -#[no_mangle] +#[unsafe(no_mangle)] pub fn get_tls() -> u8 { #[thread_local] static A: u8 = 42; diff --git a/compiler/rustc_codegen_llvm/src/abi.rs b/compiler/rustc_codegen_llvm/src/abi.rs index d29fb14e5bd40..49c07652c8261 100644 --- a/compiler/rustc_codegen_llvm/src/abi.rs +++ b/compiler/rustc_codegen_llvm/src/abi.rs @@ -27,12 +27,17 @@ use crate::llvm::{self, Attribute, AttributePlace, Type, Value}; use crate::type_of::LayoutLlvmExt; trait ArgAttributesExt { - fn apply_attrs_to_llfn(&self, idx: AttributePlace, cx: &CodegenCx<'_, '_>, llfn: &Value); - fn apply_attrs_to_callsite( + fn apply_attrs_to_llfn<'ll>( &self, idx: AttributePlace, - cx: &CodegenCx<'_, '_>, - callsite: &Value, + cx: &CodegenCx<'ll, '_>, + llfn: Value<'ll>, + ); + fn apply_attrs_to_callsite<'ll>( + &self, + idx: AttributePlace, + cx: &CodegenCx<'ll, '_>, + callsite: Value<'ll>, ); } @@ -116,16 +121,21 @@ fn get_attrs<'ll>(this: &ArgAttributes, cx: &CodegenCx<'ll, '_>) -> SmallVec<[&' } impl ArgAttributesExt for ArgAttributes { - fn apply_attrs_to_llfn(&self, idx: AttributePlace, cx: &CodegenCx<'_, '_>, llfn: &Value) { + fn apply_attrs_to_llfn<'ll>( + &self, + idx: AttributePlace, + cx: &CodegenCx<'ll, '_>, + llfn: Value<'ll>, + ) { let attrs = get_attrs(self, cx); attributes::apply_to_llfn(llfn, idx, &attrs); } - fn apply_attrs_to_callsite( + fn apply_attrs_to_callsite<'ll>( &self, idx: AttributePlace, - cx: &CodegenCx<'_, '_>, - callsite: &Value, + cx: &CodegenCx<'ll, '_>, + callsite: Value<'ll>, ) { let attrs = get_attrs(self, cx); attributes::apply_to_callsite(callsite, idx, &attrs); @@ -236,14 +246,14 @@ trait ArgAbiExt<'ll, 'tcx> { fn store( &self, bx: &mut Builder<'_, 'll, 'tcx>, - val: &'ll Value, - dst: PlaceRef<'tcx, &'ll Value>, + val: Value<'ll>, + dst: PlaceRef<'tcx, Value<'ll>>, ); fn store_fn_arg( &self, bx: &mut Builder<'_, 'll, 'tcx>, idx: &mut usize, - dst: PlaceRef<'tcx, &'ll Value>, + dst: PlaceRef<'tcx, Value<'ll>>, ); } @@ -255,8 +265,8 @@ impl<'ll, 'tcx> ArgAbiExt<'ll, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> { fn store( &self, bx: &mut Builder<'_, 'll, 'tcx>, - val: &'ll Value, - dst: PlaceRef<'tcx, &'ll Value>, + val: Value<'ll>, + dst: PlaceRef<'tcx, Value<'ll>>, ) { match &self.mode { PassMode::Ignore => {} @@ -310,7 +320,7 @@ impl<'ll, 'tcx> ArgAbiExt<'ll, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> { &self, bx: &mut Builder<'_, 'll, 'tcx>, idx: &mut usize, - dst: PlaceRef<'tcx, &'ll Value>, + dst: PlaceRef<'tcx, Value<'ll>>, ) { let mut next = || { let val = llvm::get_param(bx.llfn(), *idx as c_uint); @@ -347,8 +357,8 @@ impl<'ll, 'tcx> ArgAbiBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> { fn store_arg( &mut self, arg_abi: &ArgAbi<'tcx, Ty<'tcx>>, - val: &'ll Value, - dst: PlaceRef<'tcx, &'ll Value>, + val: Value<'ll>, + dst: PlaceRef<'tcx, Value<'ll>>, ) { arg_abi.store(self, val, dst) } @@ -363,12 +373,12 @@ pub(crate) trait FnAbiLlvmExt<'ll, 'tcx> { fn apply_attrs_llfn( &self, cx: &CodegenCx<'ll, 'tcx>, - llfn: &'ll Value, + llfn: Value<'ll>, instance: Option>, ); /// Apply attributes to a function call. - fn apply_attrs_callsite(&self, bx: &mut Builder<'_, 'll, 'tcx>, callsite: &'ll Value); + fn apply_attrs_callsite(&self, bx: &mut Builder<'_, 'll, 'tcx>, callsite: Value<'ll>); } impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> { @@ -470,7 +480,7 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> { fn apply_attrs_llfn( &self, cx: &CodegenCx<'ll, 'tcx>, - llfn: &'ll Value, + llfn: Value<'ll>, instance: Option>, ) { let mut func_attrs = SmallVec::<[_; 3]>::new(); @@ -648,7 +658,7 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> { } } - fn apply_attrs_callsite(&self, bx: &mut Builder<'_, 'll, 'tcx>, callsite: &'ll Value) { + fn apply_attrs_callsite(&self, bx: &mut Builder<'_, 'll, 'tcx>, callsite: Value<'ll>) { let mut func_attrs = SmallVec::<[_; 2]>::new(); if self.ret.layout.is_uninhabited() { func_attrs.push(llvm::AttributeKind::NoReturn.create_attr(bx.cx.llcx)); @@ -659,7 +669,7 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> { attributes::apply_to_callsite(callsite, llvm::AttributePlace::Function, &{ func_attrs }); let mut i = 0; - let mut apply = |cx: &CodegenCx<'_, '_>, attrs: &ArgAttributes| { + let mut apply = |cx: &CodegenCx<'ll, '_>, attrs: &ArgAttributes| { attrs.apply_attrs_to_callsite(llvm::AttributePlace::Argument(i), cx, callsite); i += 1; i - 1 diff --git a/compiler/rustc_codegen_llvm/src/asm.rs b/compiler/rustc_codegen_llvm/src/asm.rs index 317dc3d55a62c..c6fb235059fd1 100644 --- a/compiler/rustc_codegen_llvm/src/asm.rs +++ b/compiler/rustc_codegen_llvm/src/asm.rs @@ -537,7 +537,7 @@ pub(crate) fn inline_asm_call<'ll>( bx: &mut Builder<'_, 'll, '_>, asm: &str, cons: &str, - inputs: &[&'ll Value], + inputs: &[Value<'ll>], output: llvm::Type<'ll>, labels: &[&'ll llvm::BasicBlock], volatile: bool, @@ -547,7 +547,7 @@ pub(crate) fn inline_asm_call<'ll>( unwind: bool, dest: Option<&'ll llvm::BasicBlock>, catch_funclet: Option<(&'ll llvm::BasicBlock, Option<&Funclet<'ll>>)>, -) -> Option<&'ll Value> { +) -> Option> { let argtys = inputs .iter() .map(|v| { @@ -1170,11 +1170,11 @@ fn any_target_feature_enabled( /// Fix up an input value to work around LLVM bugs. fn llvm_fixup_input<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - mut value: &'ll Value, + mut value: Value<'ll>, reg: InlineAsmRegClass, layout: &TyAndLayout<'tcx>, instance: Instance<'_>, -) -> &'ll Value { +) -> Value<'ll> { use InlineAsmRegClass::*; let dl = &bx.tcx.data_layout; match (reg, layout.backend_repr) { @@ -1373,11 +1373,11 @@ fn llvm_fixup_input<'ll, 'tcx>( /// Fix up an output value to work around LLVM bugs. fn llvm_fixup_output<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - mut value: &'ll Value, + mut value: Value<'ll>, reg: InlineAsmRegClass, layout: &TyAndLayout<'tcx>, instance: Instance<'_>, -) -> &'ll Value { +) -> Value<'ll> { use InlineAsmRegClass::*; match (reg, layout.backend_repr) { (AArch64(AArch64InlineAsmRegClass::vreg), BackendRepr::Scalar(s)) => { diff --git a/compiler/rustc_codegen_llvm/src/attributes.rs b/compiler/rustc_codegen_llvm/src/attributes.rs index b8b2af4221e63..1a89c6491457e 100644 --- a/compiler/rustc_codegen_llvm/src/attributes.rs +++ b/compiler/rustc_codegen_llvm/src/attributes.rs @@ -26,23 +26,27 @@ use crate::llvm::{ }; use crate::{attributes, llvm_util}; -pub(crate) fn apply_to_llfn(llfn: &Value, idx: AttributePlace, attrs: &[&Attribute]) { +pub(crate) fn apply_to_llfn<'ll>(llfn: Value<'ll>, idx: AttributePlace, attrs: &[&'ll Attribute]) { if !attrs.is_empty() { llvm::AddFunctionAttributes(llfn, idx, attrs); } } -pub(crate) fn apply_to_callsite(callsite: &Value, idx: AttributePlace, attrs: &[&Attribute]) { +pub(crate) fn apply_to_callsite<'ll>( + callsite: Value<'ll>, + idx: AttributePlace, + attrs: &[&'ll Attribute], +) { if !attrs.is_empty() { llvm::AddCallSiteAttributes(callsite, idx, attrs); } } -pub(crate) fn has_string_attr(llfn: &Value, name: &str) -> bool { +pub(crate) fn has_string_attr<'ll>(llfn: Value<'ll>, name: &str) -> bool { llvm::HasStringAttribute(llfn, name) } -pub(crate) fn remove_string_attr_from_llfn(llfn: &Value, name: &str) { +pub(crate) fn remove_string_attr_from_llfn<'ll>(llfn: Value<'ll>, name: &str) { llvm::RemoveStringAttrFromFn(llfn, name); } @@ -502,7 +506,7 @@ fn create_alloc_family_attr<'ll>(llcx: llvm::Context<'ll>) -> &'ll llvm::Attribu pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>( cx: &SimpleCx<'ll>, tcx: TyCtxt<'tcx>, - llfn: &'ll Value, + llfn: Value<'ll>, codegen_fn_attrs: &CodegenFnAttrs, instance: Option>, sanitizer_ignorelist: Option<&SanitizerIgnoreList>, diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs index 4e1a3f998a265..83b5b7405d63d 100644 --- a/compiler/rustc_codegen_llvm/src/back/write.rs +++ b/compiler/rustc_codegen_llvm/src/back/write.rs @@ -659,8 +659,8 @@ pub(crate) unsafe fn llvm_optimize<'ll>( // Returns the new function, or `None` if nothing was wrapped fn handle_offload<'ll>( cx: &SimpleCx<'ll>, - old_fn: &'ll llvm::Value, - ) -> Option<&'ll llvm::Value> { + old_fn: llvm::Value<'ll>, + ) -> Option> { let old_fn_ty = cx.get_type_of_global(old_fn); let old_param_types = cx.func_params_types(old_fn_ty); let old_param_count = old_param_types.len(); diff --git a/compiler/rustc_codegen_llvm/src/base.rs b/compiler/rustc_codegen_llvm/src/base.rs index 7909072db1d8d..0b230f1608da1 100644 --- a/compiler/rustc_codegen_llvm/src/base.rs +++ b/compiler/rustc_codegen_llvm/src/base.rs @@ -34,14 +34,14 @@ use crate::llvm::{self, Value}; use crate::{ModuleLlvm, attributes}; pub(crate) struct ValueIter<'ll> { - cur: Option<&'ll Value>, - step: unsafe extern "C" fn(&'ll Value) -> Option<&'ll Value>, + cur: Option>, + step: unsafe extern "C" fn(Value<'ll>) -> Option>, } impl<'ll> Iterator for ValueIter<'ll> { - type Item = &'ll Value; + type Item = Value<'ll>; - fn next(&mut self) -> Option<&'ll Value> { + fn next(&mut self) -> Option> { let old = self.cur; if let Some(old) = old { self.cur = unsafe { (self.step)(old) }; @@ -221,7 +221,7 @@ pub(crate) fn compile_codegen_unit( (module, cost) } -pub(crate) fn set_link_section(llval: &Value, attrs: &CodegenFnAttrs) { +pub(crate) fn set_link_section<'ll>(llval: Value<'ll>, attrs: &CodegenFnAttrs) { let Some(sect) = attrs.link_section else { return }; let buf = SmallCStr::new(sect.as_str()); llvm::set_section(llval, &buf); @@ -248,7 +248,7 @@ pub(crate) fn visibility_to_llvm(linkage: Visibility) -> llvm::Visibility { } } -pub(crate) fn set_variable_sanitizer_attrs(llval: &Value, attrs: &CodegenFnAttrs) { +pub(crate) fn set_variable_sanitizer_attrs<'ll>(llval: Value<'ll>, attrs: &CodegenFnAttrs) { if attrs.sanitizers.disabled.contains(SanitizerSet::ADDRESS) || attrs.sanitizers.disabled.contains(SanitizerSet::KERNELADDRESS) { diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs index ed5da8e69246f..32e9578355976 100644 --- a/compiler/rustc_codegen_llvm/src/builder.rs +++ b/compiler/rustc_codegen_llvm/src/builder.rs @@ -61,10 +61,10 @@ impl<'a, 'll> SBuilder<'a, 'll> { pub(crate) fn call( &mut self, llty: Type<'ll>, - llfn: &'ll Value, - args: &[&'ll Value], + llfn: Value<'ll>, + args: &[Value<'ll>], funclet: Option<&Funclet<'ll>>, - ) -> &'ll Value { + ) -> Value<'ll> { debug!("call {:?} with args ({:?})", llfn, args); let args = self.check_call("call", llty, llfn, args); @@ -79,7 +79,7 @@ impl<'a, 'll> SBuilder<'a, 'll> { self.llbuilder(), llty, llfn, - args.as_ptr() as *const &llvm::Value, + args.as_ptr(), args.len() as c_uint, bundles.as_ptr(), bundles.len() as c_uint, @@ -99,7 +99,7 @@ impl<'a, 'll, CX: Borrow>> GenericBuilder<'a, 'll, CX> { pub(crate) fn append_block( cx: &'a GenericCx<'ll, CX>, - llfn: &'ll Value, + llfn: Value<'ll>, name: &str, ) -> &'ll BasicBlock { unsafe { @@ -116,11 +116,11 @@ impl<'a, 'll, CX: Borrow>> GenericBuilder<'a, 'll, CX> { unsafe { self.llbuilder_raw.as_ref() } } - pub(crate) fn trunc(&mut self, val: &'ll Value, dest_ty: Type<'ll>) -> &'ll Value { + pub(crate) fn trunc(&mut self, val: Value<'ll>, dest_ty: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMBuildTrunc(self.llbuilder(), val, dest_ty, UNNAMED) } } - pub(crate) fn bitcast(&mut self, val: &'ll Value, dest_ty: Type<'ll>) -> &'ll Value { + pub(crate) fn bitcast(&mut self, val: Value<'ll>, dest_ty: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMBuildBitCast(self.llbuilder(), val, dest_ty, UNNAMED) } } @@ -128,7 +128,7 @@ impl<'a, 'll, CX: Borrow>> GenericBuilder<'a, 'll, CX> { llvm::LLVMBuildRetVoid(self.llbuilder()); } - pub(crate) fn ret(&mut self, v: &'ll Value) { + pub(crate) fn ret(&mut self, v: Value<'ll>) { unsafe { llvm::LLVMBuildRet(self.llbuilder(), v); } @@ -146,7 +146,7 @@ impl<'a, 'll, CX: Borrow>> GenericBuilder<'a, 'll, CX> { // easily jump to the beginning of the function to place our allocas there. We trust the user // to manually do that. FIXME(offload): improve the genericCx and add more llvm wrappers to // handle this. - pub(crate) fn direct_alloca(&mut self, size: Size, align: Align, name: &str) -> &'ll Value { + pub(crate) fn direct_alloca(&mut self, size: Size, align: Align, name: &str) -> Value<'ll> { let ty = self.cx.type_array(self.cx.type_i8(), size.bytes()); let val = unsafe { let alloca = llvm::LLVMBuildAlloca(self.llbuilder(), ty, UNNAMED); @@ -163,10 +163,10 @@ impl<'a, 'll, CX: Borrow>> GenericBuilder<'a, 'll, CX> { fn build_gep( &mut self, stride: Size, - ptr: &'ll Value, - index: &'ll Value, + ptr: Value<'ll>, + index: Value<'ll>, flags: GEPNoWrapFlags, - ) -> &'ll Value { + ) -> Value<'ll> { let ty = if stride.bytes() == 1 { // LLVM prefers `i8` as the canonical form for a single-byte GEP. self.cx.type_i8() @@ -187,7 +187,7 @@ impl<'a, 'll, CX: Borrow>> GenericBuilder<'a, 'll, CX> { } } - pub(crate) fn store(&mut self, val: &'ll Value, ptr: &'ll Value, align: Align) -> &'ll Value { + pub(crate) fn store(&mut self, val: Value<'ll>, ptr: Value<'ll>, align: Align) -> Value<'ll> { debug!("Store {:?} -> {:?}", val, ptr); assert_eq!(self.cx.type_kind(self.cx.val_ty(ptr)), TypeKind::Pointer); unsafe { @@ -197,7 +197,7 @@ impl<'a, 'll, CX: Borrow>> GenericBuilder<'a, 'll, CX> { } } - pub(crate) fn load(&mut self, ty: Type<'ll>, ptr: &'ll Value, align: Align) -> &'ll Value { + pub(crate) fn load(&mut self, ty: Type<'ll>, ptr: Value<'ll>, align: Align) -> Value<'ll> { unsafe { let load = llvm::LLVMBuildLoad2(self.llbuilder(), ty, ptr, UNNAMED); llvm::LLVMSetAlignment(load, align.bytes() as c_uint); @@ -281,7 +281,7 @@ impl<'ll, 'tcx> Deref for Builder<'_, 'll, 'tcx> { macro_rules! math_builder_methods { ($($name:ident($($arg:ident),*) => $llvm_capi:ident),+ $(,)?) => { - $(fn $name(&mut self, $($arg: &'ll Value),*) -> &'ll Value { + $(fn $name(&mut self, $($arg: Value<'ll>),*) -> Value<'ll> { unsafe { llvm::$llvm_capi(self.llbuilder(), $($arg,)* UNNAMED) } @@ -291,7 +291,7 @@ macro_rules! math_builder_methods { macro_rules! set_math_builder_methods { ($($name:ident($($arg:ident),*) => ($llvm_capi:ident, $llvm_set_math:ident)),+ $(,)?) => { - $(fn $name(&mut self, $($arg: &'ll Value),*) -> &'ll Value { + $(fn $name(&mut self, $($arg: Value<'ll>),*) -> Value<'ll> { unsafe { let instr = llvm::$llvm_capi(self.llbuilder(), $($arg,)* UNNAMED); llvm::$llvm_set_math(instr); @@ -324,7 +324,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { self.span = span; } - fn append_block(cx: &'a CodegenCx<'ll, 'tcx>, llfn: &'ll Value, name: &str) -> &'ll BasicBlock { + fn append_block(cx: &'a CodegenCx<'ll, 'tcx>, llfn: Value<'ll>, name: &str) -> &'ll BasicBlock { unsafe { let name = SmallCStr::new(name); llvm::LLVMAppendBasicBlockInContext(cx.llcx, llfn, name.as_ptr()) @@ -343,7 +343,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { llvm::LLVMBuildRetVoid(self.llbuilder()); } - fn ret(&mut self, v: &'ll Value) { + fn ret(&mut self, v: Value<'ll>) { unsafe { llvm::LLVMBuildRet(self.llbuilder(), v); } @@ -399,7 +399,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { fn cond_br( &mut self, - cond: &'ll Value, + cond: Value<'ll>, then_llbb: &'ll BasicBlock, else_llbb: &'ll BasicBlock, ) { @@ -410,7 +410,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { fn switch( &mut self, - v: &'ll Value, + v: Value<'ll>, else_llbb: &'ll BasicBlock, cases: impl ExactSizeIterator, ) { @@ -465,14 +465,14 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { llty: Type<'ll>, fn_attrs: Option<&CodegenFnAttrs>, fn_abi: Option<&FnAbi<'tcx, Ty<'tcx>>>, - llfn: &'ll Value, - return_slot: ReturnSlot<&'ll Value>, - args: &[&'ll Value], + llfn: Value<'ll>, + return_slot: ReturnSlot>, + args: &[Value<'ll>], then: &'ll BasicBlock, catch: &'ll BasicBlock, funclet: Option<&Funclet<'ll>>, instance: Option>, - ) -> &'ll Value { + ) -> Value<'ll> { // If this function returns indirectly (`PassMode::Indirect`), // the `return_slot` should be the first argument. let args = match return_slot { @@ -563,7 +563,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { unchecked_umul(x, y) => LLVMBuildNUWMul, } - fn unchecked_suadd(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value { + fn unchecked_suadd(&mut self, a: Value<'ll>, b: Value<'ll>) -> Value<'ll> { unsafe { let add = llvm::LLVMBuildAdd(self.llbuilder(), a, b, UNNAMED); if llvm::LLVMIsAInstruction(add).is_some() { @@ -573,7 +573,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { add } } - fn unchecked_susub(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value { + fn unchecked_susub(&mut self, a: Value<'ll>, b: Value<'ll>) -> Value<'ll> { unsafe { let sub = llvm::LLVMBuildSub(self.llbuilder(), a, b, UNNAMED); if llvm::LLVMIsAInstruction(sub).is_some() { @@ -583,7 +583,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { sub } } - fn unchecked_sumul(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value { + fn unchecked_sumul(&mut self, a: Value<'ll>, b: Value<'ll>) -> Value<'ll> { unsafe { let mul = llvm::LLVMBuildMul(self.llbuilder(), a, b, UNNAMED); if llvm::LLVMIsAInstruction(mul).is_some() { @@ -594,7 +594,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { } } - fn or_disjoint(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value { + fn or_disjoint(&mut self, a: Value<'ll>, b: Value<'ll>) -> Value<'ll> { unsafe { let or = llvm::LLVMBuildOr(self.llbuilder(), a, b, UNNAMED); @@ -679,7 +679,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { val } - fn alloca(&mut self, size: Size, align: Align) -> &'ll Value { + fn alloca(&mut self, size: Size, align: Align) -> Value<'ll> { let mut bx = Builder::with_cx(self.cx); bx.position_at_start(unsafe { llvm::LLVMGetFirstBasicBlock(self.llfn()) }); bx.direct_alloca(size, align, "") @@ -697,7 +697,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { } } - fn load(&mut self, ty: Type<'ll>, ptr: &'ll Value, align: Align) -> &'ll Value { + fn load(&mut self, ty: Type<'ll>, ptr: Value<'ll>, align: Align) -> Value<'ll> { unsafe { let load = llvm::LLVMBuildLoad2(self.llbuilder(), ty, ptr, UNNAMED); let align = align.min(self.cx().tcx.sess.target.max_reliable_alignment()); @@ -706,7 +706,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { } } - fn volatile_load(&mut self, ty: Type<'ll>, ptr: &'ll Value, align: Align) -> &'ll Value { + fn volatile_load(&mut self, ty: Type<'ll>, ptr: Value<'ll>, align: Align) -> Value<'ll> { unsafe { let load = self.load(ty, ptr, align); llvm::LLVMSetVolatile(load, llvm::TRUE); @@ -717,11 +717,11 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { fn atomic_load( &mut self, ty: Type<'ll>, - ptr: &'ll Value, + ptr: Value<'ll>, order: rustc_middle::ty::AtomicOrdering, volatile: bool, size: Size, - ) -> &'ll Value { + ) -> Value<'ll> { unsafe { let load = llvm::LLVMBuildLoad2(self.llbuilder(), ty, ptr, UNNAMED); // Set atomic ordering @@ -736,7 +736,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { } #[instrument(level = "trace", skip(self))] - fn load_operand(&mut self, place: PlaceRef<'tcx, &'ll Value>) -> OperandRef<'tcx, &'ll Value> { + fn load_operand(&mut self, place: PlaceRef<'tcx, Value<'ll>>) -> OperandRef<'tcx, Value<'ll>> { if place.layout.is_unsized() { let tail = self.tcx.struct_tail_for_codegen(place.layout.ty, self.typing_env()); if matches!(tail.kind(), ty::Foreign(..)) { @@ -755,7 +755,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { #[instrument(level = "trace", skip(bx))] fn scalar_load_metadata<'a, 'll, 'tcx>( bx: &mut Builder<'a, 'll, 'tcx>, - load: &'ll Value, + load: Value<'ll>, scalar: abi::Scalar, layout: TyAndLayout<'tcx>, offset: Size, @@ -842,9 +842,9 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { fn write_operand_repeatedly( &mut self, - cg_elem: OperandRef<'tcx, &'ll Value>, + cg_elem: OperandRef<'tcx, Value<'ll>>, count: u64, - dest: PlaceRef<'tcx, &'ll Value>, + dest: PlaceRef<'tcx, Value<'ll>>, ) { if self.cx.sess().opts.optimize == OptLevel::No { // To let debuggers single-step over lines like @@ -860,7 +860,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { } } - fn range_metadata(&mut self, load: &'ll Value, range: WrappingRange) { + fn range_metadata(&mut self, load: Value<'ll>, range: WrappingRange) { if self.cx.sess().opts.optimize == OptLevel::No { // Don't emit metadata we're not going to use return; @@ -874,14 +874,14 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { self.set_metadata_node(load, llvm::MD_range, &md); } - fn nonnull_metadata(&mut self, load: &'ll Value) { + fn nonnull_metadata(&mut self, load: Value<'ll>) { self.set_metadata_node(load, llvm::MD_nonnull, &[]); } fn store_with_flags( &mut self, - val: &'ll Value, - ptr: &'ll Value, + val: Value<'ll>, + ptr: Value<'ll>, align: Align, flags: MemFlags, ) { @@ -940,8 +940,8 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { fn atomic_store( &mut self, - val: &'ll Value, - ptr: &'ll Value, + val: Value<'ll>, + ptr: Value<'ll>, order: rustc_middle::ty::AtomicOrdering, volatile: bool, size: Size, @@ -960,24 +960,24 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { } } - fn gep(&mut self, stride: Size, ptr: &'ll Value, index: &'ll Value) -> &'ll Value { + fn gep(&mut self, stride: Size, ptr: Value<'ll>, index: Value<'ll>) -> Value<'ll> { self.build_gep(stride, ptr, index, GEPNoWrapFlags::default()) } - fn inbounds_gep(&mut self, stride: Size, ptr: &'ll Value, index: &'ll Value) -> &'ll Value { + fn inbounds_gep(&mut self, stride: Size, ptr: Value<'ll>, index: Value<'ll>) -> Value<'ll> { self.build_gep(stride, ptr, index, GEPNoWrapFlags::InBounds) } - fn inbounds_nuw_gep(&mut self, stride: Size, ptr: &'ll Value, index: &'ll Value) -> &'ll Value { + fn inbounds_nuw_gep(&mut self, stride: Size, ptr: Value<'ll>, index: Value<'ll>) -> Value<'ll> { self.build_gep(stride, ptr, index, GEPNoWrapFlags::InBounds | GEPNoWrapFlags::NUW) } /* Casts */ - fn trunc(&mut self, val: &'ll Value, dest_ty: Type<'ll>) -> &'ll Value { + fn trunc(&mut self, val: Value<'ll>, dest_ty: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMBuildTrunc(self.llbuilder(), val, dest_ty, UNNAMED) } } - fn unchecked_utrunc(&mut self, val: &'ll Value, dest_ty: Type<'ll>) -> &'ll Value { + fn unchecked_utrunc(&mut self, val: Value<'ll>, dest_ty: Type<'ll>) -> Value<'ll> { debug_assert_ne!(self.val_ty(val), dest_ty); let trunc = self.trunc(val, dest_ty); @@ -989,7 +989,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { trunc } - fn unchecked_strunc(&mut self, val: &'ll Value, dest_ty: Type<'ll>) -> &'ll Value { + fn unchecked_strunc(&mut self, val: Value<'ll>, dest_ty: Type<'ll>) -> Value<'ll> { debug_assert_ne!(self.val_ty(val), dest_ty); let trunc = self.trunc(val, dest_ty); @@ -1001,19 +1001,19 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { trunc } - fn sext(&mut self, val: &'ll Value, dest_ty: Type<'ll>) -> &'ll Value { + fn sext(&mut self, val: Value<'ll>, dest_ty: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMBuildSExt(self.llbuilder(), val, dest_ty, UNNAMED) } } - fn fptoui_sat(&mut self, val: &'ll Value, dest_ty: Type<'ll>) -> &'ll Value { + fn fptoui_sat(&mut self, val: Value<'ll>, dest_ty: Type<'ll>) -> Value<'ll> { self.call_intrinsic("llvm.fptoui.sat", &[dest_ty, self.val_ty(val)], &[val]) } - fn fptosi_sat(&mut self, val: &'ll Value, dest_ty: Type<'ll>) -> &'ll Value { + fn fptosi_sat(&mut self, val: Value<'ll>, dest_ty: Type<'ll>) -> Value<'ll> { self.call_intrinsic("llvm.fptosi.sat", &[dest_ty, self.val_ty(val)], &[val]) } - fn fptoui(&mut self, val: &'ll Value, dest_ty: Type<'ll>) -> &'ll Value { + fn fptoui(&mut self, val: Value<'ll>, dest_ty: Type<'ll>) -> Value<'ll> { // On WebAssembly the `fptoui` and `fptosi` instructions currently have // poor codegen. The reason for this is that the corresponding wasm // instructions, `i32.trunc_f32_s` for example, will trap when the float @@ -1044,7 +1044,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { unsafe { llvm::LLVMBuildFPToUI(self.llbuilder(), val, dest_ty, UNNAMED) } } - fn fptosi(&mut self, val: &'ll Value, dest_ty: Type<'ll>) -> &'ll Value { + fn fptosi(&mut self, val: Value<'ll>, dest_ty: Type<'ll>) -> Value<'ll> { // see `fptoui` above for why wasm is different here if self.sess().target.is_like_wasm { let src_ty = self.cx.val_ty(val); @@ -1062,35 +1062,35 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { unsafe { llvm::LLVMBuildFPToSI(self.llbuilder(), val, dest_ty, UNNAMED) } } - fn uitofp(&mut self, val: &'ll Value, dest_ty: Type<'ll>) -> &'ll Value { + fn uitofp(&mut self, val: Value<'ll>, dest_ty: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMBuildUIToFP(self.llbuilder(), val, dest_ty, UNNAMED) } } - fn sitofp(&mut self, val: &'ll Value, dest_ty: Type<'ll>) -> &'ll Value { + fn sitofp(&mut self, val: Value<'ll>, dest_ty: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMBuildSIToFP(self.llbuilder(), val, dest_ty, UNNAMED) } } - fn fptrunc(&mut self, val: &'ll Value, dest_ty: Type<'ll>) -> &'ll Value { + fn fptrunc(&mut self, val: Value<'ll>, dest_ty: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMBuildFPTrunc(self.llbuilder(), val, dest_ty, UNNAMED) } } - fn fpext(&mut self, val: &'ll Value, dest_ty: Type<'ll>) -> &'ll Value { + fn fpext(&mut self, val: Value<'ll>, dest_ty: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMBuildFPExt(self.llbuilder(), val, dest_ty, UNNAMED) } } - fn ptrtoint(&mut self, val: &'ll Value, dest_ty: Type<'ll>) -> &'ll Value { + fn ptrtoint(&mut self, val: Value<'ll>, dest_ty: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMBuildPtrToInt(self.llbuilder(), val, dest_ty, UNNAMED) } } - fn inttoptr(&mut self, val: &'ll Value, dest_ty: Type<'ll>) -> &'ll Value { + fn inttoptr(&mut self, val: Value<'ll>, dest_ty: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMBuildIntToPtr(self.llbuilder(), val, dest_ty, UNNAMED) } } - fn bitcast(&mut self, val: &'ll Value, dest_ty: Type<'ll>) -> &'ll Value { + fn bitcast(&mut self, val: Value<'ll>, dest_ty: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMBuildBitCast(self.llbuilder(), val, dest_ty, UNNAMED) } } - fn intcast(&mut self, val: &'ll Value, dest_ty: Type<'ll>, is_signed: bool) -> &'ll Value { + fn intcast(&mut self, val: Value<'ll>, dest_ty: Type<'ll>, is_signed: bool) -> Value<'ll> { unsafe { llvm::LLVMBuildIntCast2( self.llbuilder(), @@ -1102,17 +1102,17 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { } } - fn pointercast(&mut self, val: &'ll Value, dest_ty: Type<'ll>) -> &'ll Value { + fn pointercast(&mut self, val: Value<'ll>, dest_ty: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMBuildPointerCast(self.llbuilder(), val, dest_ty, UNNAMED) } } /* Comparisons */ - fn icmp(&mut self, op: IntPredicate, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value { + fn icmp(&mut self, op: IntPredicate, lhs: Value<'ll>, rhs: Value<'ll>) -> Value<'ll> { let op = llvm::IntPredicate::from_generic(op); unsafe { llvm::LLVMBuildICmp(self.llbuilder(), op as c_uint, lhs, rhs, UNNAMED) } } - fn fcmp(&mut self, op: RealPredicate, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value { + fn fcmp(&mut self, op: RealPredicate, lhs: Value<'ll>, rhs: Value<'ll>) -> Value<'ll> { let op = llvm::RealPredicate::from_generic(op); unsafe { llvm::LLVMBuildFCmp(self.llbuilder(), op as c_uint, lhs, rhs, UNNAMED) } } @@ -1132,11 +1132,11 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { /* Miscellaneous instructions */ fn memcpy( &mut self, - dst: &'ll Value, + dst: Value<'ll>, dst_align: Align, - src: &'ll Value, + src: Value<'ll>, src_align: Align, - size: &'ll Value, + size: Value<'ll>, flags: MemFlags, tt: Option, ) { @@ -1167,11 +1167,11 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { fn memmove( &mut self, - dst: &'ll Value, + dst: Value<'ll>, dst_align: Align, - src: &'ll Value, + src: Value<'ll>, src_align: Align, - size: &'ll Value, + size: Value<'ll>, flags: MemFlags, ) { assert!(!flags.contains(MemFlags::NONTEMPORAL), "non-temporal memmove not supported"); @@ -1192,9 +1192,9 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { fn memset( &mut self, - ptr: &'ll Value, - fill_byte: &'ll Value, - size: &'ll Value, + ptr: Value<'ll>, + fill_byte: Value<'ll>, + size: Value<'ll>, align: Align, flags: MemFlags, ) { @@ -1212,28 +1212,28 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { } } - fn vscale(&mut self, ty: Type<'ll>) -> &'ll Value { + fn vscale(&mut self, ty: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMRustBuildVScale(self.llbuilder(), ty) } } fn select( &mut self, - cond: &'ll Value, - then_val: &'ll Value, - else_val: &'ll Value, - ) -> &'ll Value { + cond: Value<'ll>, + then_val: Value<'ll>, + else_val: Value<'ll>, + ) -> Value<'ll> { unsafe { llvm::LLVMBuildSelect(self.llbuilder(), cond, then_val, else_val, UNNAMED) } } - fn va_arg(&mut self, list: &'ll Value, ty: Type<'ll>) -> &'ll Value { + fn va_arg(&mut self, list: Value<'ll>, ty: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMBuildVAArg(self.llbuilder(), list, ty, UNNAMED) } } - fn extract_element(&mut self, vec: &'ll Value, idx: &'ll Value) -> &'ll Value { + fn extract_element(&mut self, vec: Value<'ll>, idx: Value<'ll>) -> Value<'ll> { unsafe { llvm::LLVMBuildExtractElement(self.llbuilder(), vec, idx, UNNAMED) } } - fn vector_splat(&mut self, num_elts: u64, elt: &'ll Value) -> &'ll Value { + fn vector_splat(&mut self, num_elts: u64, elt: Value<'ll>) -> Value<'ll> { unsafe { let elt_ty = self.cx.val_ty(elt); let undef = llvm::LLVMGetUndef(self.type_vector(elt_ty, num_elts)); @@ -1243,25 +1243,25 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { } } - fn extract_value(&mut self, agg_val: &'ll Value, idx: u64) -> &'ll Value { + fn extract_value(&mut self, agg_val: Value<'ll>, idx: u64) -> Value<'ll> { assert_eq!(idx as c_uint as u64, idx); unsafe { llvm::LLVMBuildExtractValue(self.llbuilder(), agg_val, idx as c_uint, UNNAMED) } } - fn insert_value(&mut self, agg_val: &'ll Value, elt: &'ll Value, idx: u64) -> &'ll Value { + fn insert_value(&mut self, agg_val: Value<'ll>, elt: Value<'ll>, idx: u64) -> Value<'ll> { assert_eq!(idx as c_uint as u64, idx); unsafe { llvm::LLVMBuildInsertValue(self.llbuilder(), agg_val, elt, idx as c_uint, UNNAMED) } } - fn set_personality_fn(&mut self, personality: &'ll Value) { + fn set_personality_fn(&mut self, personality: Value<'ll>) { unsafe { llvm::LLVMSetPersonalityFn(self.llfn(), personality); } } - fn cleanup_landing_pad(&mut self, pers_fn: &'ll Value) -> (&'ll Value, &'ll Value) { + fn cleanup_landing_pad(&mut self, pers_fn: Value<'ll>) -> (Value<'ll>, Value<'ll>) { let ty = self.type_struct(&[self.type_ptr(), self.type_i32()]); let landing_pad = self.landing_pad(ty, pers_fn, 0); unsafe { @@ -1270,13 +1270,13 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { (self.extract_value(landing_pad, 0), self.extract_value(landing_pad, 1)) } - fn filter_landing_pad(&mut self, pers_fn: &'ll Value) { + fn filter_landing_pad(&mut self, pers_fn: Value<'ll>) { let ty = self.type_struct(&[self.type_ptr(), self.type_i32()]); let landing_pad = self.landing_pad(ty, pers_fn, 1); self.add_clause(landing_pad, self.const_array(self.type_ptr(), &[])); } - fn resume(&mut self, exn0: &'ll Value, exn1: &'ll Value) { + fn resume(&mut self, exn0: Value<'ll>, exn1: Value<'ll>) { let ty = self.type_struct(&[self.type_ptr(), self.type_i32()]); let mut exn = self.const_poison(ty); exn = self.insert_value(exn, exn0, 0); @@ -1286,7 +1286,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { } } - fn cleanup_pad(&mut self, parent: Option<&'ll Value>, args: &[&'ll Value]) -> Funclet<'ll> { + fn cleanup_pad(&mut self, parent: Option>, args: &[Value<'ll>]) -> Funclet<'ll> { let ret = unsafe { llvm::LLVMBuildCleanupPad( self.llbuilder(), @@ -1306,7 +1306,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { } } - fn catch_pad(&mut self, parent: &'ll Value, args: &[&'ll Value]) -> Funclet<'ll> { + fn catch_pad(&mut self, parent: Value<'ll>, args: &[Value<'ll>]) -> Funclet<'ll> { let ret = unsafe { llvm::LLVMBuildCatchPad( self.llbuilder(), @@ -1321,10 +1321,10 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { fn catch_switch( &mut self, - parent: Option<&'ll Value>, + parent: Option>, unwind: Option<&'ll BasicBlock>, handlers: &[&'ll BasicBlock], - ) -> &'ll Value { + ) -> Value<'ll> { let ret = unsafe { llvm::LLVMBuildCatchSwitch( self.llbuilder(), @@ -1343,20 +1343,20 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { ret } - fn get_funclet_cleanuppad(&self, funclet: &Funclet<'ll>) -> &'ll Value { + fn get_funclet_cleanuppad(&self, funclet: &Funclet<'ll>) -> Value<'ll> { funclet.cleanuppad() } // Atomic Operations fn atomic_cmpxchg( &mut self, - dst: &'ll Value, - cmp: &'ll Value, - src: &'ll Value, + dst: Value<'ll>, + cmp: Value<'ll>, + src: Value<'ll>, order: rustc_middle::ty::AtomicOrdering, failure_order: rustc_middle::ty::AtomicOrdering, weak: bool, - ) -> (&'ll Value, &'ll Value) { + ) -> (Value<'ll>, Value<'ll>) { unsafe { let value = llvm::LLVMBuildAtomicCmpXchg( self.llbuilder(), @@ -1377,11 +1377,11 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { fn atomic_rmw( &mut self, op: rustc_codegen_ssa::common::AtomicRmwBinOp, - dst: &'ll Value, - src: &'ll Value, + dst: Value<'ll>, + src: Value<'ll>, order: rustc_middle::ty::AtomicOrdering, ret_ptr: bool, - ) -> &'ll Value { + ) -> Value<'ll> { // FIXME: If `ret_ptr` is true and `src` is not a pointer, we *should* tell LLVM that the // LHS is a pointer and the operation should be provenance-preserving, but LLVM does not // currently support that (https://github.com/llvm/llvm-project/issues/120837). @@ -1420,15 +1420,15 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { } } - fn set_invariant_load(&mut self, load: &'ll Value) { + fn set_invariant_load(&mut self, load: Value<'ll>) { self.set_metadata_node(load, llvm::MD_invariant_load, &[]); } - fn lifetime_start(&mut self, ptr: &'ll Value, size: Size) { + fn lifetime_start(&mut self, ptr: Value<'ll>, size: Size) { self.call_lifetime_intrinsic("llvm.lifetime.start", ptr, size); } - fn lifetime_end(&mut self, ptr: &'ll Value, size: Size) { + fn lifetime_end(&mut self, ptr: Value<'ll>, size: Size) { self.call_lifetime_intrinsic("llvm.lifetime.end", ptr, size); } @@ -1437,12 +1437,12 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { llty: Type<'ll>, caller_attrs: Option<&CodegenFnAttrs>, fn_abi: Option<&FnAbi<'tcx, Ty<'tcx>>>, - llfn: &'ll Value, - return_slot: ReturnSlot<&'ll Value>, - args: &[&'ll Value], + llfn: Value<'ll>, + return_slot: ReturnSlot>, + args: &[Value<'ll>], funclet: Option<&Funclet<'ll>>, callee_instance: Option>, - ) -> &'ll Value { + ) -> Value<'ll> { // If this function returns indirectly (`PassMode::Indirect`), // the `return_slot` should be the first argument. let args = match return_slot { @@ -1480,7 +1480,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { self.llbuilder(), llty, llfn, - args.as_ptr() as *const &llvm::Value, + args.as_ptr(), args.len() as c_uint, bundles.as_ptr(), bundles.len() as c_uint, @@ -1524,11 +1524,11 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { } } - fn zext(&mut self, val: &'ll Value, dest_ty: Type<'ll>) -> &'ll Value { + fn zext(&mut self, val: Value<'ll>, dest_ty: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMBuildZExt(self.llbuilder(), val, dest_ty, UNNAMED) } } - fn apply_attrs_to_cleanup_callsite(&mut self, llret: &'ll Value) { + fn apply_attrs_to_cleanup_callsite(&mut self, llret: Value<'ll>) { // Cleanup is always the cold path. let cold_inline = llvm::AttributeKind::Cold.create_attr(self.llcx); attributes::apply_to_callsite(llret, llvm::AttributePlace::Function, &[cold_inline]); @@ -1536,7 +1536,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { } impl<'ll> StaticBuilderMethods for Builder<'_, 'll, '_> { - fn get_static(&mut self, def_id: DefId) -> &'ll Value { + fn get_static(&mut self, def_id: DefId) -> Value<'ll> { // Forward to the `get_static` method of `CodegenCx` let global = self.cx().get_static(def_id); if self.cx().tcx.is_thread_local_static(def_id) { @@ -1552,7 +1552,7 @@ impl<'ll> StaticBuilderMethods for Builder<'_, 'll, '_> { } impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> { - pub(crate) fn llfn(&self) -> &'ll Value { + pub(crate) fn llfn(&self) -> Value<'ll> { unsafe { llvm::LLVMGetBasicBlockParent(self.llbb()) } } @@ -1561,7 +1561,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> { span: rustc_span::Span, expected_ty: String, check_kind: u8, - ) -> &'ll Value { + ) -> Value<'ll> { let cx = self.cx(); let tcx = cx.tcx; @@ -1610,24 +1610,24 @@ impl<'a, 'll, CX: Borrow>> GenericBuilder<'a, 'll, CX> { } } impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> { - fn align_metadata(&mut self, load: &'ll Value, align: Align) { + fn align_metadata(&mut self, load: Value<'ll>, align: Align) { let md = [llvm::LLVMValueAsMetadata(self.cx.const_u64(align.bytes()))]; self.set_metadata_node(load, llvm::MD_align, &md); } - fn noundef_metadata(&mut self, load: &'ll Value) { + fn noundef_metadata(&mut self, load: Value<'ll>) { self.set_metadata_node(load, llvm::MD_noundef, &[]); } - pub(crate) fn set_unpredictable(&mut self, inst: &'ll Value) { + pub(crate) fn set_unpredictable(&mut self, inst: Value<'ll>) { self.set_metadata_node(inst, llvm::MD_unpredictable, &[]); } fn write_operand_repeatedly_optimized( &mut self, - cg_elem: OperandRef<'tcx, &'ll Value>, + cg_elem: OperandRef<'tcx, Value<'ll>>, count: u64, - dest: PlaceRef<'tcx, &'ll Value>, + dest: PlaceRef<'tcx, Value<'ll>>, ) { let zero = self.const_usize(0); let count = self.const_usize(count); @@ -1657,9 +1657,9 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> { fn write_operand_repeatedly_unoptimized( &mut self, - cg_elem: OperandRef<'tcx, &'ll Value>, + cg_elem: OperandRef<'tcx, Value<'ll>>, count: u64, - dest: PlaceRef<'tcx, &'ll Value>, + dest: PlaceRef<'tcx, Value<'ll>>, ) { let zero = self.const_usize(0); let count = self.const_usize(count); @@ -1691,13 +1691,13 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> { *self = Self::build(self.cx, next_bb); } - pub(crate) fn minimum_number_nsz(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value { + pub(crate) fn minimum_number_nsz(&mut self, lhs: Value<'ll>, rhs: Value<'ll>) -> Value<'ll> { let call = self.call_intrinsic("llvm.minimumnum", &[self.val_ty(lhs)], &[lhs, rhs]); unsafe { llvm::LLVMRustSetNoSignedZeros(call) }; call } - pub(crate) fn maximum_number_nsz(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value { + pub(crate) fn maximum_number_nsz(&mut self, lhs: Value<'ll>, rhs: Value<'ll>) -> Value<'ll> { let call = self.call_intrinsic("llvm.maximumnum", &[self.val_ty(lhs)], &[lhs, rhs]); unsafe { llvm::LLVMRustSetNoSignedZeros(call) }; call @@ -1705,33 +1705,33 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> { pub(crate) fn insert_element( &mut self, - vec: &'ll Value, - elt: &'ll Value, - idx: &'ll Value, - ) -> &'ll Value { + vec: Value<'ll>, + elt: Value<'ll>, + idx: Value<'ll>, + ) -> Value<'ll> { unsafe { llvm::LLVMBuildInsertElement(self.llbuilder(), vec, elt, idx, UNNAMED) } } pub(crate) fn shuffle_vector( &mut self, - v1: &'ll Value, - v2: &'ll Value, - mask: &'ll Value, - ) -> &'ll Value { + v1: Value<'ll>, + v2: Value<'ll>, + mask: Value<'ll>, + ) -> Value<'ll> { unsafe { llvm::LLVMBuildShuffleVector(self.llbuilder(), v1, v2, mask, UNNAMED) } } - pub(crate) fn vector_reduce_fadd(&mut self, acc: &'ll Value, src: &'ll Value) -> &'ll Value { + pub(crate) fn vector_reduce_fadd(&mut self, acc: Value<'ll>, src: Value<'ll>) -> Value<'ll> { self.call_intrinsic("llvm.vector.reduce.fadd", &[self.val_ty(src)], &[acc, src]) } - pub(crate) fn vector_reduce_fmul(&mut self, acc: &'ll Value, src: &'ll Value) -> &'ll Value { + pub(crate) fn vector_reduce_fmul(&mut self, acc: Value<'ll>, src: Value<'ll>) -> Value<'ll> { self.call_intrinsic("llvm.vector.reduce.fmul", &[self.val_ty(src)], &[acc, src]) } pub(crate) fn vector_reduce_fadd_reassoc( &mut self, - acc: &'ll Value, - src: &'ll Value, - ) -> &'ll Value { + acc: Value<'ll>, + src: Value<'ll>, + ) -> Value<'ll> { unsafe { let instr = self.call_intrinsic("llvm.vector.reduce.fadd", &[self.val_ty(src)], &[acc, src]); @@ -1741,9 +1741,9 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> { } pub(crate) fn vector_reduce_fmul_reassoc( &mut self, - acc: &'ll Value, - src: &'ll Value, - ) -> &'ll Value { + acc: Value<'ll>, + src: Value<'ll>, + ) -> Value<'ll> { unsafe { let instr = self.call_intrinsic("llvm.vector.reduce.fmul", &[self.val_ty(src)], &[acc, src]); @@ -1751,29 +1751,29 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> { instr } } - pub(crate) fn vector_reduce_add(&mut self, src: &'ll Value) -> &'ll Value { + pub(crate) fn vector_reduce_add(&mut self, src: Value<'ll>) -> Value<'ll> { self.call_intrinsic("llvm.vector.reduce.add", &[self.val_ty(src)], &[src]) } - pub(crate) fn vector_reduce_mul(&mut self, src: &'ll Value) -> &'ll Value { + pub(crate) fn vector_reduce_mul(&mut self, src: Value<'ll>) -> Value<'ll> { self.call_intrinsic("llvm.vector.reduce.mul", &[self.val_ty(src)], &[src]) } - pub(crate) fn vector_reduce_and(&mut self, src: &'ll Value) -> &'ll Value { + pub(crate) fn vector_reduce_and(&mut self, src: Value<'ll>) -> Value<'ll> { self.call_intrinsic("llvm.vector.reduce.and", &[self.val_ty(src)], &[src]) } - pub(crate) fn vector_reduce_or(&mut self, src: &'ll Value) -> &'ll Value { + pub(crate) fn vector_reduce_or(&mut self, src: Value<'ll>) -> Value<'ll> { self.call_intrinsic("llvm.vector.reduce.or", &[self.val_ty(src)], &[src]) } - pub(crate) fn vector_reduce_xor(&mut self, src: &'ll Value) -> &'ll Value { + pub(crate) fn vector_reduce_xor(&mut self, src: Value<'ll>) -> Value<'ll> { self.call_intrinsic("llvm.vector.reduce.xor", &[self.val_ty(src)], &[src]) } - pub(crate) fn vector_reduce_min(&mut self, src: &'ll Value, is_signed: bool) -> &'ll Value { + pub(crate) fn vector_reduce_min(&mut self, src: Value<'ll>, is_signed: bool) -> Value<'ll> { self.call_intrinsic( if is_signed { "llvm.vector.reduce.smin" } else { "llvm.vector.reduce.umin" }, &[self.val_ty(src)], &[src], ) } - pub(crate) fn vector_reduce_max(&mut self, src: &'ll Value, is_signed: bool) -> &'ll Value { + pub(crate) fn vector_reduce_max(&mut self, src: Value<'ll>, is_signed: bool) -> Value<'ll> { self.call_intrinsic( if is_signed { "llvm.vector.reduce.smax" } else { "llvm.vector.reduce.umax" }, &[self.val_ty(src)], @@ -1782,7 +1782,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> { } } impl<'a, 'll, CX: Borrow>> GenericBuilder<'a, 'll, CX> { - pub(crate) fn add_clause(&mut self, landing_pad: &'ll Value, clause: &'ll Value) { + pub(crate) fn add_clause(&mut self, landing_pad: Value<'ll>, clause: Value<'ll>) { unsafe { llvm::LLVMAddClause(landing_pad, clause); } @@ -1792,7 +1792,7 @@ impl<'a, 'll, CX: Borrow>> GenericBuilder<'a, 'll, CX> { &mut self, funclet: &Funclet<'ll>, unwind: &'ll BasicBlock, - ) -> &'ll Value { + ) -> Value<'ll> { let ret = unsafe { llvm::LLVMBuildCatchRet(self.llbuilder(), funclet.cleanuppad(), unwind) }; ret.expect("LLVM does not have support for catchret") @@ -1802,9 +1802,9 @@ impl<'a, 'll, CX: Borrow>> GenericBuilder<'a, 'll, CX> { &mut self, typ: &str, fn_ty: Type<'ll>, - llfn: &'ll Value, - args: &'b [&'ll Value], - ) -> Cow<'b, [&'ll Value]> { + llfn: Value<'ll>, + args: &'b [Value<'ll>], + ) -> Cow<'b, [Value<'ll>]> { assert!( self.cx.type_kind(fn_ty) == TypeKind::Function, "builder::{typ} not passed a function, but {fn_ty:?}" @@ -1839,7 +1839,7 @@ impl<'a, 'll, CX: Borrow>> GenericBuilder<'a, 'll, CX> { Cow::Owned(casted_args) } - pub(crate) fn va_arg(&mut self, list: &'ll Value, ty: Type<'ll>) -> &'ll Value { + pub(crate) fn va_arg(&mut self, list: Value<'ll>, ty: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMBuildVAArg(self.llbuilder(), list, ty, UNNAMED) } } } @@ -1849,14 +1849,14 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> { &mut self, base_name: impl Into>, type_params: &[Type<'ll>], - args: &[&'ll Value], - ) -> &'ll Value { + args: &[Value<'ll>], + ) -> Value<'ll> { let (ty, f) = self.cx.get_intrinsic(base_name.into(), type_params); // No LLVM intrinsic returns its data indirectly (via `sret`). self.call(ty, None, None, f, ReturnSlot::Direct, args, None, None) } - fn call_lifetime_intrinsic(&mut self, intrinsic: &'static str, ptr: &'ll Value, size: Size) { + fn call_lifetime_intrinsic(&mut self, intrinsic: &'static str, ptr: Value<'ll>, size: Size) { let size = size.bytes(); if size == 0 { return; @@ -1876,9 +1876,9 @@ impl<'a, 'll, CX: Borrow>> GenericBuilder<'a, 'll, CX> { pub(crate) fn phi( &mut self, ty: Type<'ll>, - vals: &[&'ll Value], + vals: &[Value<'ll>], bbs: &[&'ll BasicBlock], - ) -> &'ll Value { + ) -> Value<'ll> { assert_eq!(vals.len(), bbs.len()); let phi = unsafe { llvm::LLVMBuildPhi(self.llbuilder(), ty, UNNAMED) }; unsafe { @@ -1887,7 +1887,7 @@ impl<'a, 'll, CX: Borrow>> GenericBuilder<'a, 'll, CX> { } } - fn add_incoming_to_phi(&mut self, phi: &'ll Value, val: &'ll Value, bb: &'ll BasicBlock) { + fn add_incoming_to_phi(&mut self, phi: Value<'ll>, val: Value<'ll>, bb: &'ll BasicBlock) { unsafe { llvm::LLVMAddIncoming(phi, &val, &bb, 1 as c_uint); } @@ -1897,9 +1897,9 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> { pub(crate) fn landing_pad( &mut self, ty: Type<'ll>, - pers_fn: &'ll Value, + pers_fn: Value<'ll>, num_clauses: usize, - ) -> &'ll Value { + ) -> Value<'ll> { // Use LLVMSetPersonalityFn to set the personality. It supports arbitrary Consts while, // LLVMBuildLandingPad requires the argument to be a Function (as of LLVM 12). The // personality lives on the parent function anyway. @@ -1914,13 +1914,13 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> { llty: Type<'ll>, fn_attrs: Option<&CodegenFnAttrs>, fn_abi: Option<&FnAbi<'tcx, Ty<'tcx>>>, - llfn: &'ll Value, - args: &[&'ll Value], + llfn: Value<'ll>, + args: &[Value<'ll>], default_dest: &'ll BasicBlock, indirect_dest: &[&'ll BasicBlock], funclet: Option<&Funclet<'ll>>, instance: Option>, - ) -> &'ll Value { + ) -> Value<'ll> { debug!("invoke {:?} with args ({:?})", llfn, args); let args = self.check_call("callbr", llty, llfn, args); @@ -1971,7 +1971,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> { fn_attrs: Option<&CodegenFnAttrs>, fn_abi: Option<&FnAbi<'tcx, Ty<'tcx>>>, instance: Option>, - llfn: &'ll Value, + llfn: Value<'ll>, ) { let is_indirect_call = unsafe { llvm::LLVMRustIsNonGVFunctionPointerTy(llfn) }; if self.tcx.sess.is_sanitizer_cfi_enabled() @@ -2107,7 +2107,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> { fn_attrs: Option<&CodegenFnAttrs>, fn_abi: Option<&FnAbi<'tcx, Ty<'tcx>>>, instance: Option>, - llfn: &'ll Value, + llfn: Value<'ll>, ) -> Option> { let is_indirect_call = unsafe { llvm::LLVMRustIsNonGVFunctionPointerTy(llfn) }; let kcfi_bundle = if self.tcx.sess.is_sanitizer_kcfi_enabled() @@ -2151,7 +2151,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> { // Emits pauth operand bundle. fn ptrauth_operand_bundle( &mut self, - llfn: &'ll Value, + llfn: Value<'ll>, fn_abi: Option<&FnAbi<'tcx, Ty<'tcx>>>, ) -> Option> { let schema = self.sess().pointer_authentication_functions()?; @@ -2186,10 +2186,10 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> { #[instrument(level = "debug", skip(self))] pub(crate) fn instrprof_increment( &mut self, - fn_name: &'ll Value, - hash: &'ll Value, - num_counters: &'ll Value, - index: &'ll Value, + fn_name: Value<'ll>, + hash: Value<'ll>, + num_counters: Value<'ll>, + index: Value<'ll>, ) { self.call_intrinsic("llvm.instrprof.increment", &[], &[fn_name, hash, num_counters, index]); } diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs index 4c83f0a64248f..72ce05213fb7d 100644 --- a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs +++ b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs @@ -136,9 +136,9 @@ pub(crate) fn adjust_activity_to_abi<'tcx>( fn match_args_from_caller_to_enzyme<'ll, 'tcx>( builder: &mut Builder<'_, 'll, 'tcx>, width: u32, - args: &mut Vec<&'ll Value>, + args: &mut Vec>, inputs: &[DiffActivity], - outer_args: &[&'ll Value], + outer_args: &[Value<'ll>], ) { debug!("matching autodiff arguments"); // We now handle the issue that Rust level arguments not always match the llvm-ir level @@ -166,7 +166,7 @@ fn match_args_from_caller_to_enzyme<'ll, 'tcx>( let diff_activity = inputs[activity_pos as usize]; // Duplicated arguments received a shadow argument, into which enzyme will write the // gradient. - let (activity, duplicated): (&Value, bool) = match diff_activity { + let (activity, duplicated): (Value<'ll>, bool) = match diff_activity { DiffActivity::None => panic!("not a valid input activity"), DiffActivity::Const => (global_const, false), DiffActivity::Active => (global_out, false), @@ -284,15 +284,15 @@ fn match_args_from_caller_to_enzyme<'ll, 'tcx>( // cover some assumptions of enzyme/autodiff, which could lead to UB otherwise. pub(crate) fn generate_enzyme_call<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - fn_to_diff: &'ll Value, + fn_to_diff: Value<'ll>, outer_name: &str, ret_ty: Type<'ll>, - fn_args: &[&'ll Value], + fn_args: &[Value<'ll>], attrs: &RustcAutodiff, dest_layout: ty::layout::TyAndLayout<'tcx>, - dest_place: Option>, + dest_place: Option>>, fnc_tree: FncTree, -) -> IntrinsicResult<'tcx, &'ll Value> { +) -> IntrinsicResult<'tcx, Value<'ll>> { let cx: &SimpleCx<'ll> = &bx.scx; // We have to pick the name depending on whether we want forward or reverse mode autodiff. let mut ad_name: String = match attrs.mode { @@ -346,7 +346,7 @@ pub(crate) fn generate_enzyme_call<'ll, 'tcx>( enzyme_ty, ); - let num_args = llvm::LLVMCountParams(&fn_to_diff); + let num_args = llvm::LLVMCountParams(fn_to_diff); let mut args = Vec::with_capacity(num_args as usize + 1); args.push(fn_to_diff); diff --git a/compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs b/compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs index 46526b6bce421..f26c02fe394eb 100644 --- a/compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs +++ b/compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs @@ -21,18 +21,18 @@ use crate::llvm::{self, Linkage, Type, TypeKind, Value}; // LLVM kernel-independent globals required for offloading pub(crate) struct OffloadGlobals<'ll> { - pub launcher_fn: &'ll llvm::Value, + pub launcher_fn: llvm::Value<'ll>, pub launcher_ty: llvm::Type<'ll>, pub kernel_args_ty: KernelArgsTy, pub offload_entry_ty: llvm::Type<'ll>, - pub begin_mapper: &'ll llvm::Value, - pub end_mapper: &'ll llvm::Value, + pub begin_mapper: llvm::Value<'ll>, + pub end_mapper: llvm::Value<'ll>, pub mapper_fn_ty: llvm::Type<'ll>, - pub ident_t_global: &'ll llvm::Value, + pub ident_t_global: llvm::Value<'ll>, } impl<'ll> OffloadGlobals<'ll> { @@ -61,22 +61,22 @@ impl<'ll> OffloadGlobals<'ll> { } pub(crate) struct OffloadKernelDims<'ll> { - num_workgroups: &'ll Value, - threads_per_block: &'ll Value, - workgroup_dims: [&'ll Value; 3], - thread_dims: [&'ll Value; 3], + num_workgroups: Value<'ll>, + threads_per_block: Value<'ll>, + workgroup_dims: [Value<'ll>; 3], + thread_dims: [Value<'ll>; 3], } impl<'ll> OffloadKernelDims<'ll> { pub(crate) fn from_operands<'tcx>( builder: &mut Builder<'_, 'll, 'tcx>, - workgroup_op: &OperandRef<'tcx, &'ll llvm::Value>, - thread_op: &OperandRef<'tcx, &'ll llvm::Value>, + workgroup_op: &OperandRef<'tcx, llvm::Value<'ll>>, + thread_op: &OperandRef<'tcx, llvm::Value<'ll>>, ) -> Self { fn load_3_u32<'ll>( builder: &mut Builder<'_, 'll, '_>, - place: PlaceValue<&'ll Value>, - ) -> [&'ll Value; 3] { + place: PlaceValue>, + ) -> [Value<'ll>; 3] { let ty = builder.type_i32(); let size = 4; let v0 = builder.load(ty, place.llval, place.align); @@ -100,8 +100,8 @@ impl<'ll> OffloadKernelDims<'ll> { fn mul_dim3<'ll, 'tcx>( builder: &mut Builder<'_, 'll, 'tcx>, - [x, y, z]: [&'ll Value; 3], - ) -> &'ll Value { + [x, y, z]: [Value<'ll>; 3], + ) -> Value<'ll> { let xy = builder.mul(x, y); builder.mul(xy, z) } @@ -120,7 +120,7 @@ impl<'ll> OffloadKernelDims<'ll> { // ; Function Attrs: nounwind // declare i32 @__tgt_target_kernel(ptr, i64, i32, i32, ptr, ptr) #2 -fn generate_launcher<'ll>(cx: &CodegenCx<'ll, '_>) -> (&'ll llvm::Value, llvm::Type<'ll>) { +fn generate_launcher<'ll>(cx: &CodegenCx<'ll, '_>) -> (llvm::Value<'ll>, llvm::Type<'ll>) { let tptr = cx.type_ptr(); let ti64 = cx.type_i64(); let ti32 = cx.type_i32(); @@ -137,7 +137,7 @@ fn generate_launcher<'ll>(cx: &CodegenCx<'ll, '_>) -> (&'ll llvm::Value, llvm::T /// declaration together with its type. pub(crate) fn declare_omp_get_num_devices<'ll>( cx: &CodegenCx<'ll, '_>, -) -> (&'ll llvm::Value, llvm::Type<'ll>) { +) -> (llvm::Value<'ll>, llvm::Type<'ll>) { let ti32 = cx.type_i32(); let tgt_fn_ty = cx.type_func(&[], ti32); let name = "omp_get_num_devices"; @@ -152,7 +152,7 @@ pub(crate) fn declare_omp_get_num_devices<'ll>( // @1 = private unnamed_addr constant %struct.ident_t { i32 0, i32 2, i32 0, i32 22, ptr @0 }, align 8 // FIXME(offload): @0 should include the file name (e.g. lib.rs) in which the function to be // offloaded was defined. -pub(crate) fn generate_at_one<'ll>(cx: &CodegenCx<'ll, '_>) -> &'ll llvm::Value { +pub(crate) fn generate_at_one<'ll>(cx: &CodegenCx<'ll, '_>) -> llvm::Value<'ll> { let unknown_txt = ";unknown;unknown;0;0;;"; let c_entry_name = CString::new(unknown_txt).unwrap(); let c_val = c_entry_name.as_bytes_with_nul(); @@ -205,9 +205,9 @@ impl TgtOffloadEntry { fn new<'ll>( cx: &CodegenCx<'ll, '_>, - region_id: &'ll Value, - llglobal: &'ll Value, - ) -> [&'ll Value; 9] { + region_id: Value<'ll>, + llglobal: Value<'ll>, + ) -> [Value<'ll>; 9] { let reserved = cx.get_const_i64(0); let version = cx.get_const_i16(1); let kind = cx.get_const_i16(1); @@ -291,12 +291,12 @@ impl KernelArgsTy { fn new<'ll, 'tcx>( cx: &CodegenCx<'ll, 'tcx>, num_args: u64, - memtransfer_types: &'ll Value, - geps: [&'ll Value; 3], - workgroup_dims: [&'ll Value; 3], - thread_dims: [&'ll Value; 3], - dyn_cache: &'ll Value, - ) -> [&'ll Value; Self::FIELD_COUNT] { + memtransfer_types: Value<'ll>, + geps: [Value<'ll>; 3], + workgroup_dims: [Value<'ll>; 3], + thread_dims: [Value<'ll>; 3], + dyn_cache: Value<'ll>, + ) -> [Value<'ll>; Self::FIELD_COUNT] { [ // Version cx.get_const_i32(KernelArgsTy::OFFLOAD_VERSION), @@ -336,16 +336,16 @@ impl KernelArgsTy { // Contains LLVM values needed to manage offloading for a single kernel. #[derive(Copy, Clone)] pub(crate) struct OffloadKernelGlobals<'ll> { - pub offload_sizes: &'ll llvm::Value, - pub memtransfer_begin: &'ll llvm::Value, - pub memtransfer_kernel: &'ll llvm::Value, - pub memtransfer_end: &'ll llvm::Value, - pub region_id: &'ll llvm::Value, + pub offload_sizes: llvm::Value<'ll>, + pub memtransfer_begin: llvm::Value<'ll>, + pub memtransfer_kernel: llvm::Value<'ll>, + pub memtransfer_end: llvm::Value<'ll>, + pub region_id: llvm::Value<'ll>, } fn gen_tgt_data_mappers<'ll>( cx: &CodegenCx<'ll, '_>, -) -> (&'ll llvm::Value, &'ll llvm::Value, &'ll llvm::Value, llvm::Type<'ll>) { +) -> (llvm::Value<'ll>, llvm::Value<'ll>, llvm::Value<'ll>, llvm::Type<'ll>) { let tptr = cx.type_ptr(); let ti64 = cx.type_i64(); let ti32 = cx.type_i32(); @@ -367,7 +367,7 @@ fn gen_tgt_data_mappers<'ll>( (begin_mapper_decl, update_mapper_decl, end_mapper_decl, mapper_fn_ty) } -fn add_priv_unnamed_arr<'ll>(cx: &SimpleCx<'ll>, name: &str, vals: &[u64]) -> &'ll llvm::Value { +fn add_priv_unnamed_arr<'ll>(cx: &SimpleCx<'ll>, name: &str, vals: &[u64]) -> llvm::Value<'ll> { let ti64 = cx.type_i64(); let mut size_val = Vec::with_capacity(vals.len()); for &val in vals { @@ -380,9 +380,9 @@ fn add_priv_unnamed_arr<'ll>(cx: &SimpleCx<'ll>, name: &str, vals: &[u64]) -> &' pub(crate) fn add_unnamed_global<'ll>( cx: &SimpleCx<'ll>, name: &str, - initializer: &'ll llvm::Value, + initializer: llvm::Value<'ll>, l: Linkage, -) -> &'ll llvm::Value { +) -> llvm::Value<'ll> { let llglobal = add_global(cx, name, initializer, l); llvm::LLVMSetUnnamedAddress(llglobal, llvm::UnnamedAddr::Global); llglobal @@ -391,11 +391,11 @@ pub(crate) fn add_unnamed_global<'ll>( pub(crate) fn add_global<'ll>( cx: &SimpleCx<'ll>, name: &str, - initializer: &'ll llvm::Value, + initializer: llvm::Value<'ll>, l: Linkage, -) -> &'ll llvm::Value { +) -> llvm::Value<'ll> { let c_name = CString::new(name).unwrap(); - let llglobal: &'ll llvm::Value = llvm::add_global(cx.llmod, cx.val_ty(initializer), &c_name); + let llglobal: llvm::Value<'ll> = llvm::add_global(cx.llmod, cx.val_ty(initializer), &c_name); llvm::set_global_constant(llglobal, true); llvm::set_linkage(llglobal, l); llvm::set_initializer(llglobal, initializer); @@ -513,7 +513,7 @@ fn declare_offload_fn<'ll>( cx: &CodegenCx<'ll, '_>, name: &str, ty: llvm::Type<'ll>, -) -> &'ll llvm::Value { +) -> llvm::Value<'ll> { crate::declare::declare_simple_fn( cx, name, @@ -538,10 +538,10 @@ pub(crate) fn scalar_width<'ll>(cx: &SimpleCx<'ll>, ty: Type<'ll>) -> u64 { fn get_runtime_size<'ll, 'tcx>( builder: &mut Builder<'_, 'll, 'tcx>, - args: &[&'ll Value], + args: &[Value<'ll>], index: usize, meta: &OffloadMetadata, -) -> &'ll Value { +) -> Value<'ll> { match meta.payload_size { OffloadSize::Slice { element_size } => { let length_idx = index + 1; @@ -574,23 +574,23 @@ fn get_runtime_size<'ll, 'tcx>( pub(crate) fn gen_call_handling<'ll, 'tcx>( builder: &mut Builder<'_, 'll, 'tcx>, offload_data: &OffloadKernelGlobals<'ll>, - args: &[&'ll Value], + args: &[Value<'ll>], types: &[Type<'ll>], metadata: &[OffloadMetadata], offload_globals: &OffloadGlobals<'ll>, offload_dims: &OffloadKernelDims<'ll>, - dyn_cache: &'ll Value, - device_id: &'ll Value, + dyn_cache: Value<'ll>, + device_id: Value<'ll>, ) { let cx = builder.cx; - let OffloadKernelGlobals { + let &OffloadKernelGlobals { offload_sizes, memtransfer_begin, memtransfer_kernel, memtransfer_end, region_id, } = offload_data; - let OffloadKernelDims { num_workgroups, threads_per_block, workgroup_dims, thread_dims } = + let &OffloadKernelDims { num_workgroups, threads_per_block, workgroup_dims, thread_dims } = offload_dims; let has_dynamic = metadata.iter().any(|m| !matches!(m.payload_size, OffloadSize::Static(_))); @@ -696,22 +696,22 @@ pub(crate) fn gen_call_handling<'ll, 'tcx>( // offload_{baseptrs,ptrs,sizes}. We will probably improve this along with our gpu frontend pr. fn get_geps<'ll, 'tcx>( _builder: &mut Builder<'_, 'll, 'tcx>, - a1: &'ll Value, - a2: &'ll Value, - a4: &'ll Value, + a1: Value<'ll>, + a2: Value<'ll>, + a4: Value<'ll>, _is_dynamic: bool, - ) -> [&'ll Value; 3] { + ) -> [Value<'ll>; 3] { [a1, a2, a4] } fn generate_mapper_call<'ll, 'tcx>( builder: &mut Builder<'_, 'll, 'tcx>, - geps: [&'ll Value; 3], - o_type: &'ll Value, - fn_to_call: &'ll Value, + geps: [Value<'ll>; 3], + o_type: Value<'ll>, + fn_to_call: Value<'ll>, fn_ty: Type<'ll>, num_args: u64, - s_ident_t: &'ll Value, + s_ident_t: Value<'ll>, ) { let cx = builder.cx; let nullptr = cx.const_null(cx.type_ptr()); @@ -739,8 +739,8 @@ pub(crate) fn gen_call_handling<'ll, 'tcx>( num_args, memtransfer_kernel, geps, - *workgroup_dims, - *thread_dims, + workgroup_dims, + thread_dims, dyn_cache, ); diff --git a/compiler/rustc_codegen_llvm/src/callee.rs b/compiler/rustc_codegen_llvm/src/callee.rs index df18b029b02c0..743324fab7f98 100644 --- a/compiler/rustc_codegen_llvm/src/callee.rs +++ b/compiler/rustc_codegen_llvm/src/callee.rs @@ -16,7 +16,7 @@ use crate::llvm::{self, Value}; /// Codegens a reference to a fn/method item, monomorphizing and /// inlining as it goes. -pub(crate) fn get_fn<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, instance: Instance<'tcx>) -> &'ll Value { +pub(crate) fn get_fn<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, instance: Instance<'tcx>) -> Value<'ll> { let tcx = cx.tcx(); debug!("get_fn(instance={:?})", instance); diff --git a/compiler/rustc_codegen_llvm/src/common.rs b/compiler/rustc_codegen_llvm/src/common.rs index b2ce873154bcc..7e47267a29f8b 100644 --- a/compiler/rustc_codegen_llvm/src/common.rs +++ b/compiler/rustc_codegen_llvm/src/common.rs @@ -28,9 +28,9 @@ use crate::llvm::{ pub(crate) fn maybe_sign_fn_ptr<'ll, 'tcx>( cx: &CodegenCx<'ll, '_>, instance: Instance<'tcx>, - llfn: &'ll llvm::Value, + llfn: llvm::Value<'ll>, schema: &PointerAuthSchema, -) -> &'ll llvm::Value { +) -> llvm::Value<'ll> { if cx.tcx.sess.pointer_authentication_functions().is_none() { return llfn; } @@ -106,16 +106,16 @@ pub(crate) fn maybe_sign_fn_ptr<'ll, 'tcx>( /// annotated with which landing pad it's a part of. This is accomplished via /// the `OperandBundleDef` value created for MSVC landing pads. pub(crate) struct Funclet<'ll> { - cleanuppad: &'ll Value, + cleanuppad: Value<'ll>, operand: llvm::OperandBundleBox<'ll>, } impl<'ll> Funclet<'ll> { - pub(crate) fn new(cleanuppad: &'ll Value) -> Self { + pub(crate) fn new(cleanuppad: Value<'ll>) -> Self { Funclet { cleanuppad, operand: llvm::OperandBundleBox::new("funclet", &[cleanuppad]) } } - pub(crate) fn cleanuppad(&self) -> &'ll Value { + pub(crate) fn cleanuppad(&self) -> Value<'ll> { self.cleanuppad } @@ -126,11 +126,11 @@ impl<'ll> Funclet<'ll> { impl<'ll, CX: Borrow>> BackendTypes for GenericCx<'ll, CX> { // FIXME(eddyb) replace this with a `Function` "subclass" of `Value`. - type Function = &'ll Value; + type Function = Value<'ll>; type BasicBlock = &'ll BasicBlock; type Funclet = Funclet<'ll>; - type Value = &'ll Value; + type Value = Value<'ll>; type Type = Type<'ll>; type FunctionSignature = Type<'ll>; @@ -140,20 +140,20 @@ impl<'ll, CX: Borrow>> BackendTypes for GenericCx<'ll, CX> { } impl<'ll, CX: Borrow>> GenericCx<'ll, CX> { - pub(crate) fn const_array(&self, ty: Type<'ll>, elts: &[&'ll Value]) -> &'ll Value { + pub(crate) fn const_array(&self, ty: Type<'ll>, elts: &[Value<'ll>]) -> Value<'ll> { let len = u64::try_from(elts.len()).expect("LLVMConstArray2 elements len overflow"); unsafe { llvm::LLVMConstArray2(ty, elts.as_ptr(), len) } } - pub(crate) fn const_bytes(&self, bytes: &[u8]) -> &'ll Value { + pub(crate) fn const_bytes(&self, bytes: &[u8]) -> Value<'ll> { bytes_in_context(self.llcx(), bytes) } - pub(crate) fn null_terminate_const_bytes(&self, bytes: &[u8]) -> &'ll Value { + pub(crate) fn null_terminate_const_bytes(&self, bytes: &[u8]) -> Value<'ll> { null_terminate_bytes_in_context(self.llcx(), bytes) } - pub(crate) fn const_get_elt(&self, v: &'ll Value, idx: u64) -> &'ll Value { + pub(crate) fn const_get_elt(&self, v: Value<'ll>, idx: u64) -> Value<'ll> { unsafe { let idx = c_uint::try_from(idx).expect("LLVMGetAggregateElement index overflow"); let r = llvm::LLVMGetAggregateElement(v, idx).unwrap(); @@ -164,11 +164,11 @@ impl<'ll, CX: Borrow>> GenericCx<'ll, CX> { } } - pub(crate) fn const_null(&self, t: Type<'ll>) -> &'ll Value { + pub(crate) fn const_null(&self, t: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMConstNull(t) } } - pub(crate) fn const_struct(&self, elts: &[&'ll Value], packed: bool) -> &'ll Value { + pub(crate) fn const_struct(&self, elts: &[Value<'ll>], packed: bool) -> Value<'ll> { struct_in_context(self.llcx(), elts, packed) } } @@ -179,7 +179,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> { global_alloc: GlobalAlloc<'tcx>, need_symbol_name: bool, schema: Option<&PointerAuthSchema>, - ) -> Result<&'ll Value, u64> { + ) -> Result, u64> { let alloc = match global_alloc { GlobalAlloc::Function { instance, .. } => { return Ok(self.get_fn_addr(instance, schema)); @@ -262,39 +262,39 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> { } impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> { - fn const_null(&self, t: Type<'ll>) -> &'ll Value { + fn const_null(&self, t: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMConstNull(t) } } - fn const_undef(&self, t: Type<'ll>) -> &'ll Value { + fn const_undef(&self, t: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMGetUndef(t) } } - fn const_poison(&self, t: Type<'ll>) -> &'ll Value { + fn const_poison(&self, t: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMGetPoison(t) } } - fn const_bool(&self, val: bool) -> &'ll Value { + fn const_bool(&self, val: bool) -> Value<'ll> { self.const_uint(self.type_i1(), val as u64) } - fn const_i8(&self, i: i8) -> &'ll Value { + fn const_i8(&self, i: i8) -> Value<'ll> { self.const_int(self.type_i8(), i as i64) } - fn const_i16(&self, i: i16) -> &'ll Value { + fn const_i16(&self, i: i16) -> Value<'ll> { self.const_int(self.type_i16(), i as i64) } - fn const_i32(&self, i: i32) -> &'ll Value { + fn const_i32(&self, i: i32) -> Value<'ll> { self.const_int(self.type_i32(), i as i64) } - fn const_i64(&self, i: i64) -> &'ll Value { + fn const_i64(&self, i: i64) -> Value<'ll> { self.const_int(self.type_i64(), i as i64) } - fn const_int(&self, t: Type<'ll>, i: i64) -> &'ll Value { + fn const_int(&self, t: Type<'ll>, i: i64) -> Value<'ll> { debug_assert!( self.type_kind(t) == TypeKind::Integer, "only allows integer types in const_int" @@ -302,23 +302,23 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> { unsafe { llvm::LLVMConstInt(t, i as u64, TRUE) } } - fn const_u8(&self, i: u8) -> &'ll Value { + fn const_u8(&self, i: u8) -> Value<'ll> { self.const_uint(self.type_i8(), i as u64) } - fn const_u32(&self, i: u32) -> &'ll Value { + fn const_u32(&self, i: u32) -> Value<'ll> { self.const_uint(self.type_i32(), i as u64) } - fn const_u64(&self, i: u64) -> &'ll Value { + fn const_u64(&self, i: u64) -> Value<'ll> { self.const_uint(self.type_i64(), i) } - fn const_u128(&self, i: u128) -> &'ll Value { + fn const_u128(&self, i: u128) -> Value<'ll> { self.const_uint_big(self.type_i128(), i) } - fn const_usize(&self, i: u64) -> &'ll Value { + fn const_usize(&self, i: u64) -> Value<'ll> { let bit_size = self.data_layout().pointer_size().bits(); if bit_size < 64 { // make sure it doesn't overflow @@ -328,7 +328,7 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> { self.const_uint(self.isize_ty, i) } - fn const_uint(&self, t: Type<'ll>, i: u64) -> &'ll Value { + fn const_uint(&self, t: Type<'ll>, i: u64) -> Value<'ll> { debug_assert!( self.type_kind(t) == TypeKind::Integer, "only allows integer types in const_uint" @@ -336,7 +336,7 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> { unsafe { llvm::LLVMConstInt(t, i, FALSE) } } - fn const_uint_big(&self, t: Type<'ll>, u: u128) -> &'ll Value { + fn const_uint_big(&self, t: Type<'ll>, u: u128) -> Value<'ll> { debug_assert!( self.type_kind(t) == TypeKind::Integer, "only allows integer types in const_uint_big" @@ -347,11 +347,11 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> { } } - fn const_real(&self, t: Type<'ll>, val: f64) -> &'ll Value { + fn const_real(&self, t: Type<'ll>, val: f64) -> Value<'ll> { unsafe { llvm::LLVMConstReal(t, val) } } - fn const_str(&self, s: &str) -> (&'ll Value, &'ll Value) { + fn const_str(&self, s: &str) -> (Value<'ll>, Value<'ll>) { let mut const_str_cache = self.const_str_cache.borrow_mut(); let str_global = const_str_cache.get(s).copied().unwrap_or_else(|| { let sc = self.const_bytes(s.as_bytes()); @@ -374,16 +374,16 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> { (str_global, self.const_usize(len as u64)) } - fn const_struct(&self, elts: &[&'ll Value], packed: bool) -> &'ll Value { + fn const_struct(&self, elts: &[Value<'ll>], packed: bool) -> Value<'ll> { struct_in_context(self.llcx, elts, packed) } - fn const_vector(&self, elts: &[&'ll Value]) -> &'ll Value { + fn const_vector(&self, elts: &[Value<'ll>]) -> Value<'ll> { let len = c_uint::try_from(elts.len()).expect("LLVMConstVector elements len overflow"); unsafe { llvm::LLVMConstVector(elts.as_ptr(), len) } } - fn const_to_opt_uint(&self, v: &'ll Value) -> Option { + fn const_to_opt_uint(&self, v: Value<'ll>) -> Option { try_as_const_integral(v).and_then(|v| unsafe { let mut i = 0u64; let success = llvm::LLVMRustConstIntGetZExtValue(v, &mut i); @@ -391,7 +391,7 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> { }) } - fn const_to_opt_u128(&self, v: &'ll Value, sign_ext: bool) -> Option { + fn const_to_opt_u128(&self, v: Value<'ll>, sign_ext: bool) -> Option { try_as_const_integral(v).and_then(|v| unsafe { let (mut lo, mut hi) = (0u64, 0u64); let success = llvm::LLVMRustConstInt128Get(v, sign_ext, &mut hi, &mut lo); @@ -405,7 +405,7 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> { layout: abi::Scalar, llty: Type<'ll>, schema: Option<&PointerAuthSchema>, - ) -> &'ll Value { + ) -> Value<'ll> { let bitsize = if layout.is_bool() { 1 } else { layout.size(self).bits() }; match cv { Scalar::Int(int) => { @@ -464,31 +464,31 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> { } /// Get the [LLVM type][Type] of a [`Value`]. -pub(crate) fn val_ty<'ll>(v: &'ll Value) -> Type<'ll> { +pub(crate) fn val_ty<'ll>(v: Value<'ll>) -> Type<'ll> { unsafe { llvm::LLVMTypeOf(v) } } -pub(crate) fn bytes_in_context<'ll>(llcx: llvm::Context<'ll>, bytes: &[u8]) -> &'ll Value { +pub(crate) fn bytes_in_context<'ll>(llcx: llvm::Context<'ll>, bytes: &[u8]) -> Value<'ll> { unsafe { llvm::LLVMConstStringInContext2(llcx, bytes.as_ptr(), bytes.len(), TRUE) } } pub(crate) fn null_terminate_bytes_in_context<'ll>( llcx: llvm::Context<'ll>, bytes: &[u8], -) -> &'ll Value { +) -> Value<'ll> { unsafe { llvm::LLVMConstStringInContext2(llcx, bytes.as_ptr(), bytes.len(), FALSE) } } -pub(crate) fn named_struct<'ll>(ty: Type<'ll>, elts: &[&'ll Value]) -> &'ll Value { +pub(crate) fn named_struct<'ll>(ty: Type<'ll>, elts: &[Value<'ll>]) -> Value<'ll> { let len = c_uint::try_from(elts.len()).expect("LLVMConstStructInContext elements len overflow"); unsafe { llvm::LLVMConstNamedStruct(ty, elts.as_ptr(), len) } } fn struct_in_context<'ll>( llcx: llvm::Context<'ll>, - elts: &[&'ll Value], + elts: &[Value<'ll>], packed: bool, -) -> &'ll Value { +) -> Value<'ll> { let len = c_uint::try_from(elts.len()).expect("LLVMConstStructInContext elements len overflow"); unsafe { llvm::LLVMConstStructInContext(llcx, elts.as_ptr(), len, packed.to_llvm_bool()) } } @@ -498,7 +498,7 @@ fn hi_lo_to_u128(lo: u64, hi: u64) -> u128 { ((hi as u128) << 64) | (lo as u128) } -fn try_as_const_integral(v: &Value) -> Option<&ConstantInt> { +fn try_as_const_integral<'ll>(v: Value<'ll>) -> Option<&'ll ConstantInt> { unsafe { llvm::LLVMIsAConstantInt(v) } } diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs index 33d48642812e6..4952fdc732e9f 100644 --- a/compiler/rustc_codegen_llvm/src/consts.rs +++ b/compiler/rustc_codegen_llvm/src/consts.rs @@ -40,7 +40,7 @@ pub(crate) fn const_alloc_to_llvm<'ll>( alloc: &Allocation, is_static: IsStatic, is_init_fini: IsInitOrFini, -) -> &'ll Value { +) -> Value<'ll> { // We expect that callers of const_alloc_to_llvm will instead directly codegen a pointer or // integer for any &ZST where the ZST is a constant (i.e. not a static). We should never be // producing empty LLVM allocations as they're just adding noise to binaries and forcing less @@ -59,7 +59,7 @@ pub(crate) fn const_alloc_to_llvm<'ll>( // Note: this function may call `inspect_with_uninit_and_ptr_outside_interpreter`, so `range` // must be within the bounds of `alloc` and not contain or overlap a pointer provenance. fn append_chunks_of_init_and_uninit_bytes<'ll, 'a, 'b>( - llvals: &mut Vec<&'ll Value>, + llvals: &mut Vec>, cx: &'a CodegenCx<'ll, 'b>, alloc: &'a Allocation, range: Range, @@ -157,7 +157,7 @@ pub(crate) fn const_alloc_to_llvm<'ll>( fn codegen_static_initializer<'ll, 'tcx>( cx: &CodegenCx<'ll, 'tcx>, def_id: DefId, -) -> Result<(&'ll Value, ConstAllocation<'tcx>), ErrorHandled> { +) -> Result<(Value<'ll>, ConstAllocation<'tcx>), ErrorHandled> { let alloc = cx.tcx.eval_static_initializer(def_id)?; let attrs = cx.tcx.codegen_fn_attrs(def_id); // FIXME(jchlanda) Decide if this could be better served by `ctor` crate. See the discussion @@ -176,7 +176,7 @@ fn codegen_static_initializer<'ll, 'tcx>( Ok((const_alloc_to_llvm(cx, alloc.inner(), IsStatic::Yes, is_in_init_fini), alloc)) } -fn set_global_alignment<'ll>(cx: &CodegenCx<'ll, '_>, gv: &'ll Value, mut align: Align) { +fn set_global_alignment<'ll>(cx: &CodegenCx<'ll, '_>, gv: Value<'ll>, mut align: Align) { // The target may require greater alignment for globals than the type does. // Note: GCC and Clang also allow `__attribute__((aligned))` on variables, // which can force it to be smaller. Rust doesn't support this yet. @@ -192,7 +192,7 @@ fn check_and_apply_linkage<'ll, 'tcx>( llty: Type<'ll>, sym: &str, def_id: DefId, -) -> &'ll Value { +) -> Value<'ll> { if let Some(linkage) = attrs.import_linkage { debug!("get_static: sym={} linkage={:?}", sym, linkage); @@ -281,11 +281,11 @@ fn check_and_apply_linkage<'ll, 'tcx>( } impl<'ll> CodegenCx<'ll, '_> { - pub(crate) fn const_bitcast(&self, val: &'ll Value, ty: Type<'ll>) -> &'ll Value { + pub(crate) fn const_bitcast(&self, val: Value<'ll>, ty: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMConstBitCast(val, ty) } } - pub(crate) fn const_pointercast(&self, val: &'ll Value, ty: Type<'ll>) -> &'ll Value { + pub(crate) fn const_pointercast(&self, val: Value<'ll>, ty: Type<'ll>) -> Value<'ll> { unsafe { llvm::LLVMConstPointerCast(val, ty) } } @@ -295,10 +295,10 @@ impl<'ll> CodegenCx<'ll, '_> { /// Fails if a symbol with the given name already exists. pub(crate) fn static_addr_of_mut( &self, - cv: &'ll Value, + cv: Value<'ll>, align: Align, kind: Option<&str>, - ) -> &'ll Value { + ) -> Value<'ll> { let gv = match kind { Some(kind) if !self.tcx.sess.fewer_names() => { let name = self.generate_local_symbol_name(kind); @@ -323,10 +323,10 @@ impl<'ll> CodegenCx<'ll, '_> { /// The returned global variable is a pointer in the default address space for globals. pub(crate) fn static_addr_of_impl( &self, - cv: &'ll Value, + cv: Value<'ll>, align: Align, kind: Option<&str>, - ) -> &'ll Value { + ) -> Value<'ll> { if let Some(&gv) = self.const_globals.borrow().get(&cv) { unsafe { // Upgrade the alignment in cases where the same constant is used with different @@ -346,7 +346,7 @@ impl<'ll> CodegenCx<'ll, '_> { } #[instrument(level = "debug", skip(self))] - pub(crate) fn get_static(&self, def_id: DefId) -> &'ll Value { + pub(crate) fn get_static(&self, def_id: DefId) -> Value<'ll> { let instance = Instance::mono(self.tcx, def_id); trace!(?instance); @@ -364,7 +364,7 @@ impl<'ll> CodegenCx<'ll, '_> { } #[instrument(level = "debug", skip(self, llty))] - fn get_static_inner(&self, def_id: DefId, llty: Type<'ll>) -> &'ll Value { + fn get_static_inner(&self, def_id: DefId, llty: Type<'ll>) -> Value<'ll> { let instance = Instance::mono(self.tcx, def_id); if let Some(&g) = self.instances.borrow().get(&instance) { trace!("used cached value"); @@ -474,7 +474,7 @@ impl<'ll> CodegenCx<'ll, '_> { fn codegen_static_item(&mut self, def_id: DefId) { assert!( llvm::LLVMGetInitializer( - self.instances.borrow().get(&Instance::mono(self.tcx, def_id)).unwrap() + self.instances.borrow().get(&Instance::mono(self.tcx, def_id)).copied().unwrap() ) .is_none() ); @@ -678,20 +678,20 @@ impl<'ll> CodegenCx<'ll, '_> { } /// Add a global value to a list to be stored in the `llvm.used` variable, an array of ptr. - pub(crate) fn add_used_global(&mut self, global: &'ll Value) { + pub(crate) fn add_used_global(&mut self, global: Value<'ll>) { self.used_statics.push(global); } /// Add a global value to a list to be stored in the `llvm.compiler.used` variable, /// an array of ptr. - pub(crate) fn add_compiler_used_global(&self, global: &'ll Value) { + pub(crate) fn add_compiler_used_global(&self, global: Value<'ll>) { self.compiler_used_statics.borrow_mut().push(global); } // We do our best here to match what Clang does when compiling Objective-C natively. // See Clang's `CGObjCCommonMac::CreateCStringLiteral`: // https://github.com/llvm/llvm-project/blob/llvmorg-20.1.8/clang/lib/CodeGen/CGObjCMac.cpp#L4134 - fn define_objc_classname(&self, classname: &str) -> &'ll Value { + fn define_objc_classname(&self, classname: &str) -> Value<'ll> { assert_eq!(self.objc_abi_version(), 1); let llval = self.null_terminate_const_bytes(classname.as_bytes()); @@ -742,7 +742,7 @@ impl<'ll> CodegenCx<'ll, '_> { // deduplicate references within a CGU, but we need a reference definition in each referencing // CGU. All attempts at using external references to a single reference definition result in // linker errors. - fn get_objc_classref(&self, classname: Symbol) -> &'ll Value { + fn get_objc_classref(&self, classname: Symbol) -> Value<'ll> { let mut classrefs = self.objc_classrefs.borrow_mut(); if let Some(classref) = classrefs.get(&classname).copied() { return classref; @@ -800,7 +800,7 @@ impl<'ll> CodegenCx<'ll, '_> { // Newer versions of Apple Clang generate calls to `@"objc_msgSend$methname"` selector stub // functions. We don't currently do that. The code we generate is closer to what Apple Clang // generates with the `-fno-objc-msgsend-selector-stubs` option. - fn get_objc_selref(&self, methname: Symbol) -> &'ll Value { + fn get_objc_selref(&self, methname: Symbol) -> Value<'ll> { let mut selrefs = self.objc_selrefs.borrow_mut(); if let Some(selref) = selrefs.get(&methname).copied() { return selref; @@ -911,7 +911,7 @@ impl<'ll> StaticCodegenMethods for CodegenCx<'ll, '_> { /// /// The pointer will always be in the default address space. If global variables default to a /// different address space, an addrspacecast is inserted. - fn static_addr_of(&self, alloc: ConstAllocation<'_>, kind: Option<&str>) -> &'ll Value { + fn static_addr_of(&self, alloc: ConstAllocation<'_>, kind: Option<&str>) -> Value<'ll> { // FIXME: should we cache `const_alloc_to_llvm` to avoid repeating this for the // same `ConstAllocation`? let cv = const_alloc_to_llvm(self, alloc.inner(), IsStatic::No, IsInitOrFini::No); diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs index 2156ac783758a..56f0be1a89e2a 100644 --- a/compiler/rustc_codegen_llvm/src/context.rs +++ b/compiler/rustc_codegen_llvm/src/context.rs @@ -101,30 +101,30 @@ pub(crate) struct FullCx<'ll, 'tcx> { pub codegen_unit: &'tcx CodegenUnit<'tcx>, /// Cache instances of monomorphic and polymorphic items - pub instances: RefCell, &'ll Value>>, + pub instances: RefCell, Value<'ll>>>, /// Cache instances of intrinsics - pub intrinsic_instances: RefCell, &'ll Value>>, + pub intrinsic_instances: RefCell, Value<'ll>>>, /// Cache generated vtables - pub vtables: RefCell, Option>), &'ll Value>>, + pub vtables: RefCell, Option>), Value<'ll>>>, /// Cache of constant strings, - pub const_str_cache: RefCell>, + pub const_str_cache: RefCell>>, /// Cache of emitted const globals (value -> global) - pub const_globals: RefCell>, + pub const_globals: RefCell, Value<'ll>>>, /// List of globals for static variables which need to be passed to the /// LLVM function ReplaceAllUsesWith (RAUW) when codegen is complete. /// (We have to make sure we don't invalidate any Values referring /// to constants.) - pub statics_to_rauw: RefCell>, + pub statics_to_rauw: RefCell, Value<'ll>)>>, /// Statics that will be placed in the llvm.used variable /// See for details - pub used_statics: Vec<&'ll Value>, + pub used_statics: Vec>, /// Statics that will be placed in the llvm.compiler.used variable /// See for details - pub compiler_used_statics: RefCell>, + pub compiler_used_statics: RefCell>>, /// Mapping of non-scalar types to llvm types. pub type_lowering: RefCell, Option), Type<'ll>>>, @@ -137,11 +137,11 @@ pub(crate) struct FullCx<'ll, 'tcx> { pub dbg_cx: Option>, pub sanitizer_ignorelist: Option, - eh_personality: Cell>, - pub rust_try_fn: Cell, &'ll Value)>>, + eh_personality: Cell>>, + pub rust_try_fn: Cell, Value<'ll>)>>, intrinsics: - RefCell, SmallVec<[Type<'ll>; 2]>), (Type<'ll>, &'ll Value)>>, + RefCell, SmallVec<[Type<'ll>; 2]>), (Type<'ll>, Value<'ll>)>>, /// A counter that is used for generating local symbol names local_gen_sym_counter: Cell, @@ -153,16 +153,16 @@ pub(crate) struct FullCx<'ll, 'tcx> { /// different type and clear the symbol name of the original global. /// `global_asm!` needs to be able to find this new global so that it can /// compute the correct mangled symbol name to insert into the asm. - pub renamed_statics: RefCell>, + pub renamed_statics: RefCell>>, /// Cached Objective-C class type pub objc_class_t: Cell>>, /// Cache of Objective-C class references - pub objc_classrefs: RefCell>, + pub objc_classrefs: RefCell>>, /// Cache of Objective-C selector references - pub objc_selrefs: RefCell>, + pub objc_selrefs: RefCell>>, /// Globals shared by the offloading runtime pub offload_globals: RefCell>>, @@ -739,7 +739,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> { ) } - pub(crate) fn statics_to_rauw(&self) -> &RefCell> { + pub(crate) fn statics_to_rauw(&self) -> &RefCell, Value<'ll>)>> { &self.statics_to_rauw } @@ -750,7 +750,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> { self.coverage_cx.as_ref().expect("only called when coverage instrumentation is enabled") } - pub(crate) fn create_used_variable_impl(&self, name: &'static CStr, values: &[&'ll Value]) { + pub(crate) fn create_used_variable_impl(&self, name: &'static CStr, values: &[Value<'ll>]) { let array = self.const_array(self.type_ptr(), values); let g = llvm::add_global(self.llmod, self.val_ty(array), name); @@ -875,10 +875,10 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> { } } impl<'ll> SimpleCx<'ll> { - pub(crate) fn get_type_of_global(&self, val: &'ll Value) -> Type<'ll> { + pub(crate) fn get_type_of_global(&self, val: Value<'ll>) -> Type<'ll> { unsafe { llvm::LLVMGlobalGetValueType(val) } } - pub(crate) fn val_ty(&self, v: &'ll Value) -> Type<'ll> { + pub(crate) fn val_ty(&self, v: Value<'ll>) -> Type<'ll> { common::val_ty(v) } } @@ -894,27 +894,27 @@ impl<'ll> SimpleCx<'ll> { } impl<'ll, CX: Borrow>> GenericCx<'ll, CX> { - pub(crate) fn get_metadata_value(&self, metadata: &'ll Metadata) -> &'ll Value { + pub(crate) fn get_metadata_value(&self, metadata: &'ll Metadata) -> Value<'ll> { llvm::LLVMMetadataAsValue(self.llcx(), metadata) } - pub(crate) fn get_const_int(&self, ty: Type<'ll>, val: u64) -> &'ll Value { + pub(crate) fn get_const_int(&self, ty: Type<'ll>, val: u64) -> Value<'ll> { unsafe { llvm::LLVMConstInt(ty, val, llvm::FALSE) } } - pub(crate) fn get_const_i64(&self, n: u64) -> &'ll Value { + pub(crate) fn get_const_i64(&self, n: u64) -> Value<'ll> { self.get_const_int(self.type_i64(), n) } - pub(crate) fn get_const_i32(&self, n: u64) -> &'ll Value { + pub(crate) fn get_const_i32(&self, n: u64) -> Value<'ll> { self.get_const_int(self.type_i32(), n) } - pub(crate) fn get_const_i16(&self, n: u64) -> &'ll Value { + pub(crate) fn get_const_i16(&self, n: u64) -> Value<'ll> { self.get_const_int(self.type_i16(), n) } - pub(crate) fn get_const_i8(&self, n: u64) -> &'ll Value { + pub(crate) fn get_const_i8(&self, n: u64) -> Value<'ll> { self.get_const_int(self.type_i8(), n) } @@ -926,7 +926,7 @@ impl<'ll, CX: Borrow>> GenericCx<'ll, CX> { unsafe { llvm::LLVMMDStringInContext2(self.llcx(), name.as_ptr(), name.len()) } } - pub(crate) fn get_functions(&self) -> Vec<&'ll Value> { + pub(crate) fn get_functions(&self) -> Vec> { let mut functions = vec![]; let mut func = unsafe { llvm::LLVMGetFirstFunction(self.llmod()) }; while let Some(f) = func { @@ -940,7 +940,7 @@ impl<'ll, CX: Borrow>> GenericCx<'ll, CX> { impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> { fn vtables( &self, - ) -> &RefCell, Option>), &'ll Value>> { + ) -> &RefCell, Option>), Value<'ll>>> { &self.vtables } @@ -948,12 +948,12 @@ impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> { &self, ty: Ty<'tcx>, poly_trait_ref: Option>, - vtable: &'ll Value, + vtable: Value<'ll>, ) { apply_vcall_visibility_metadata(self, ty, poly_trait_ref, vtable); } - fn get_fn(&self, instance: Instance<'tcx>) -> &'ll Value { + fn get_fn(&self, instance: Instance<'tcx>) -> Value<'ll> { get_fn(self, instance) } @@ -961,7 +961,7 @@ impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> { &self, instance: Instance<'tcx>, pointer_auth_schema: Option<&PointerAuthSchema>, - ) -> &'ll Value { + ) -> Value<'ll> { // When pointer authentication metadata is provided, `get_fn_addr` will // attempt to sign the pointer using LLVM's `ConstPtrAuth` constant // expression. @@ -981,7 +981,7 @@ impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> { } } - fn eh_personality(&self) -> &'ll Value { + fn eh_personality(&self) -> Value<'ll> { // The exception handling personality function. // // If our compilation unit has the `eh_personality` lang item somewhere @@ -1058,20 +1058,20 @@ impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> { self.tcx.sess } - fn set_frame_pointer_type(&self, llfn: &'ll Value) { + fn set_frame_pointer_type(&self, llfn: Value<'ll>) { if let Some(attr) = attributes::frame_pointer_type_attr(self, self.sess()) { attributes::apply_to_llfn(llfn, llvm::AttributePlace::Function, &[attr]); } } - fn apply_target_cpu_attr(&self, llfn: &'ll Value) { + fn apply_target_cpu_attr(&self, llfn: Value<'ll>) { let mut attrs = SmallVec::<[_; 2]>::new(); attrs.push(attributes::target_cpu_attr(self, self.sess())); attrs.extend(attributes::tune_cpu_attr(self, self.sess())); attributes::apply_to_llfn(llfn, llvm::AttributePlace::Function, &attrs); } - fn apply_default_optimisation_attrs(&self, llfn: &'ll Value) { + fn apply_default_optimisation_attrs(&self, llfn: Value<'ll>) { let attrs = attributes::default_optimisation_attrs(self, self.sess()); attributes::apply_to_llfn(llfn, llvm::AttributePlace::Function, &attrs); } @@ -1108,7 +1108,7 @@ impl<'ll> CodegenCx<'ll, '_> { &self, base_name: Cow<'static, str>, type_params: &[Type<'ll>], - ) -> (Type<'ll>, &'ll Value) { + ) -> (Type<'ll>, Value<'ll>) { *self .intrinsics .borrow_mut() @@ -1122,7 +1122,7 @@ impl<'ll> CodegenCx<'ll, '_> { &self, base_name: &str, type_params: &[Type<'ll>], - ) -> (Type<'ll>, &'ll Value) { + ) -> (Type<'ll>, Value<'ll>) { match base_name { // This isn't an "LLVM intrinsic", but LLVM's optimization passes // recognize it like one (including turning it into `bcmp` sometimes) @@ -1204,12 +1204,7 @@ impl<'ll, CX: Borrow>> GenericCx<'ll, CX> { } /// A wrapper for [`llvm::LLVMSetMetadata`], but it takes `Metadata` as a parameter instead of `Value`. - pub(crate) fn set_metadata<'a>( - &self, - val: &'a Value, - kind_id: MetadataKindId, - md: &'ll Metadata, - ) { + pub(crate) fn set_metadata(&self, val: Value<'ll>, kind_id: MetadataKindId, md: &'ll Metadata) { let node = self.get_metadata_value(md); llvm::LLVMSetMetadata(val, kind_id, node); } @@ -1220,7 +1215,7 @@ impl<'ll, CX: Borrow>> GenericCx<'ll, CX> { /// - `LLVMSetMetadata` (to set that node as metadata of `kind_id` for `instruction`) pub(crate) fn set_metadata_node( &self, - instruction: &'ll Value, + instruction: Value<'ll>, kind_id: MetadataKindId, md_list: &[&'ll Metadata], ) -> &'ll Metadata { @@ -1249,7 +1244,7 @@ impl<'ll, CX: Borrow>> GenericCx<'ll, CX> { /// - `LLVMGlobalAddMetadata` (to set that node as metadata of `kind_id` for `global`) pub(crate) fn global_add_metadata_node( &self, - global: &'ll Value, + global: Value<'ll>, kind_id: MetadataKindId, md_list: &[&'ll Metadata], ) { @@ -1262,7 +1257,7 @@ impl<'ll, CX: Borrow>> GenericCx<'ll, CX> { /// - `LLVMGlobalSetMetadata` (to set that node as metadata of `kind_id` for `global`) pub(crate) fn global_set_metadata_node( &self, - global: &'ll Value, + global: Value<'ll>, kind_id: MetadataKindId, md_list: &[&'ll Metadata], ) { diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs index 92abe16eb4109..4467204abc7cd 100644 --- a/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs +++ b/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs @@ -27,9 +27,9 @@ pub(crate) fn covfun_section_name<'ll>(llmod: llvm::Module<'ll>) -> CString { } pub(crate) fn create_pgo_func_name_var<'ll>( - llfn: &'ll llvm::Value, + llfn: llvm::Value<'ll>, mangled_fn_name: &str, -) -> &'ll llvm::Value { +) -> llvm::Value<'ll> { unsafe { llvm::LLVMRustCoverageCreatePGOFuncNameVar( llfn, diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs index b33e6dbb3409a..e677b5fa62250 100644 --- a/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs +++ b/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs @@ -26,7 +26,7 @@ pub(crate) struct CguCoverageContext<'ll, 'tcx> { /// emitting covfun records. Every covfun record holds a hash of its /// symbol name, and `llvm-cov` will exit fatally if it can't resolve that /// hash back to an entry in the binary's `__llvm_prf_names` linker section. - pub(crate) pgo_func_name_var_map: RefCell, &'ll llvm::Value>>, + pub(crate) pgo_func_name_var_map: RefCell, llvm::Value<'ll>>>, covfun_section_name: OnceCell, } @@ -71,10 +71,10 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> { /// /// This has the side-effect of causing coverage codegen to consider this /// function "used", making it eligible to emit an associated covfun record. - fn ensure_pgo_func_name_var(&self, instance: Instance<'tcx>) -> &'ll llvm::Value { + fn ensure_pgo_func_name_var(&self, instance: Instance<'tcx>) -> llvm::Value<'ll> { debug!("getting pgo_func_name_var for instance={:?}", instance); let mut pgo_func_name_var_map = self.coverage_cx().pgo_func_name_var_map.borrow_mut(); - pgo_func_name_var_map.entry(instance).or_insert_with(|| { + *pgo_func_name_var_map.entry(instance).or_insert_with(|| { let llfn = self.get_fn(instance); let mangled_fn_name: &str = self.tcx.symbol_name(instance).name; llvm_cov::create_pgo_func_name_var(llfn, mangled_fn_name) diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/di_builder.rs b/compiler/rustc_codegen_llvm/src/debuginfo/di_builder.rs index 9237c8be87473..c6cd73673de67 100644 --- a/compiler/rustc_codegen_llvm/src/debuginfo/di_builder.rs +++ b/compiler/rustc_codegen_llvm/src/debuginfo/di_builder.rs @@ -52,7 +52,7 @@ pub(crate) trait DIBuilderExt<'ll> { line_number: c_uint, ty: &'ll llvm::Metadata, is_local_to_unit: bool, - val: &'ll llvm::Value, + val: llvm::Value<'ll>, decl: Option<&'ll llvm::Metadata>, align: Option, ) -> &'ll llvm::Metadata { diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs b/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs index 7665c824f1c48..c5c535ff26e59 100644 --- a/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs +++ b/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs @@ -28,7 +28,7 @@ pub(crate) fn insert_reference_to_gdb_debug_scripts_section_global(bx: &mut Buil /// section. pub(crate) fn get_or_insert_gdb_debug_scripts_section_global<'ll>( cx: &CodegenCx<'ll, '_>, -) -> &'ll Value { +) -> Value<'ll> { let c_section_var_name = c"__rustc_debug_gdb_scripts_section__"; let section_var_name = c_section_var_name.to_str().unwrap(); diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs index 585d0b20420a4..ff0b924f5701e 100644 --- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs +++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs @@ -1513,7 +1513,7 @@ fn build_generic_type_param_di_nodes<'ll, 'tcx>( pub(crate) fn build_global_var_di_node<'ll>( cx: &CodegenCx<'ll, '_>, def_id: DefId, - global: &'ll Value, + global: Value<'ll>, ) { if cx.dbg_cx.is_none() { return; @@ -1722,7 +1722,7 @@ fn build_unsafe_binder_type_di_node<'ll, 'tcx>( /// global variable (which is simply returned), or an addrspacecast constant expression. /// If the given value is an addrspacecast, the cast is removed and the global variable behind /// the cast is returned. -fn find_vtable_behind_cast<'ll>(vtable: &'ll Value) -> &'ll Value { +fn find_vtable_behind_cast<'ll>(vtable: Value<'ll>) -> Value<'ll> { // The vtable is a global variable, which may be behind an addrspacecast. unsafe { if let Some(c) = llvm::LLVMIsAConstantExpr(vtable) { @@ -1738,7 +1738,7 @@ pub(crate) fn apply_vcall_visibility_metadata<'ll, 'tcx>( cx: &CodegenCx<'ll, 'tcx>, ty: Ty<'tcx>, trait_ref: Option>, - vtable: &'ll Value, + vtable: Value<'ll>, ) { // FIXME(flip1995): The virtual function elimination optimization only works with full LTO in // LLVM at the moment. @@ -1803,7 +1803,7 @@ pub(crate) fn create_vtable_di_node<'ll, 'tcx>( cx: &CodegenCx<'ll, 'tcx>, ty: Ty<'tcx>, poly_trait_ref: Option>, - vtable: &'ll Value, + vtable: Value<'ll>, ) { if cx.dbg_cx.is_none() { return; diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/cpp_like.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/cpp_like.rs index fe7f38fb195bc..100037d55b79d 100644 --- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/cpp_like.rs +++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/cpp_like.rs @@ -982,7 +982,7 @@ fn create_static_member_type<'ll>( line_number: c_uint, ty: &'ll llvm::Metadata, flags: DIFlags, - value: Option<&'ll llvm::Value>, + value: Option>, align: Align, ) -> &'ll llvm::Metadata { unsafe { diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs index 5fe5ee3e92fea..687d3bbd6b780 100644 --- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs +++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs @@ -130,7 +130,7 @@ impl<'ll, 'tcx> DebugInfoBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> { &mut self, instance: Instance<'tcx>, fn_abi: &FnAbi<'tcx, Ty<'tcx>>, - maybe_definition_llfn: Option<&'ll Value>, + maybe_definition_llfn: Option>, ) -> &'ll DIScope { let tcx = self.tcx; @@ -590,7 +590,7 @@ impl<'ll, 'tcx> DebugInfoBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> { gdb::insert_reference_to_gdb_debug_scripts_section_global(self) } - fn set_var_name(&mut self, value: &'ll Value, name: &str) { + fn set_var_name(&mut self, value: Value<'ll>, name: &str) { // Avoid wasting time if LLVM value names aren't even enabled. if self.sess().fewer_names() { return; diff --git a/compiler/rustc_codegen_llvm/src/declare.rs b/compiler/rustc_codegen_llvm/src/declare.rs index a0c9faf47a1a5..e6fef61285c6b 100644 --- a/compiler/rustc_codegen_llvm/src/declare.rs +++ b/compiler/rustc_codegen_llvm/src/declare.rs @@ -40,7 +40,7 @@ pub(crate) fn declare_simple_fn<'ll>( unnamed: llvm::UnnamedAddr, visibility: llvm::Visibility, ty: Type<'ll>, -) -> &'ll Value { +) -> Value<'ll> { debug!("declare_simple_fn(name={:?}, ty={:?})", name, ty); let llfn = unsafe { llvm::LLVMGetOrInsertFunction(cx.llmod, name.as_ptr(), name.len(), ty) }; @@ -62,7 +62,7 @@ pub(crate) fn declare_raw_fn<'ll, 'tcx>( unnamed: llvm::UnnamedAddr, visibility: llvm::Visibility, ty: Type<'ll>, -) -> &'ll Value { +) -> Value<'ll> { debug!("declare_raw_fn(name={:?}, ty={:?})", name, ty); let llfn = declare_simple_fn(cx, name, callconv, unnamed, visibility, ty); @@ -91,7 +91,7 @@ impl<'ll, CX: Borrow>> GenericCx<'ll, CX> { /// /// If there’s a value with the same name already declared, the function will /// return its Value instead. - pub(crate) fn declare_global(&self, name: &str, ty: Type<'ll>) -> &'ll Value { + pub(crate) fn declare_global(&self, name: &str, ty: Type<'ll>) -> Value<'ll> { debug!("declare_global(name={:?})", name); unsafe { llvm::LLVMRustGetOrInsertGlobal((**self).borrow().llmod, name.as_ptr(), name.len(), ty) @@ -107,7 +107,7 @@ impl<'ll, CX: Borrow>> GenericCx<'ll, CX> { name: &str, ty: Type<'ll>, addr_space: AddressSpace, - ) -> &'ll Value { + ) -> Value<'ll> { debug!("declare_global(name={name:?}, addrspace={addr_space:?})"); unsafe { llvm::LLVMRustGetOrInsertGlobalInAddrspace( @@ -134,7 +134,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> { name: &str, unnamed: llvm::UnnamedAddr, fn_type: Type<'ll>, - ) -> &'ll Value { + ) -> Value<'ll> { // Visibility should always be default for declarations, otherwise the linker may report an // error. declare_raw_fn(self, name, llvm::CCallConv, unnamed, Visibility::Default, fn_type) @@ -153,7 +153,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> { callconv: llvm::CallConv, unnamed: llvm::UnnamedAddr, fn_type: Type<'ll>, - ) -> &'ll Value { + ) -> Value<'ll> { let visibility = Visibility::from_generic(self.tcx.sess.default_visibility()); declare_raw_fn(self, name, callconv, unnamed, visibility, fn_type) } @@ -167,7 +167,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> { name: &str, fn_abi: &FnAbi<'tcx, Ty<'tcx>>, instance: Option>, - ) -> &'ll Value { + ) -> Value<'ll> { debug!("declare_rust_fn(name={:?}, fn_abi={:?})", name, fn_abi); // Some calling conventions (such as fastcall and vectorcall) decorate // symbols with the argument byte count. Use rustc's original argument @@ -256,7 +256,7 @@ impl<'ll, CX: Borrow>> GenericCx<'ll, CX> { /// return `None` if the name already has a definition associated with it. In that /// case an error should be reported to the user, because it usually happens due /// to user’s fault (e.g., misuse of `#[no_mangle]` or `#[export_name]` attributes). - pub(crate) fn define_global(&self, name: &str, ty: Type<'ll>) -> Option<&'ll Value> { + pub(crate) fn define_global(&self, name: &str, ty: Type<'ll>) -> Option> { if self.get_defined_value(name).is_some() { None } else { @@ -265,14 +265,14 @@ impl<'ll, CX: Borrow>> GenericCx<'ll, CX> { } /// Gets declared value by name. - pub(crate) fn get_declared_value(&self, name: &str) -> Option<&'ll Value> { + pub(crate) fn get_declared_value(&self, name: &str) -> Option> { debug!("get_declared_value(name={:?})", name); unsafe { llvm::LLVMRustGetNamedValue(self.llmod(), name.as_ptr(), name.len()) } } /// Gets defined or externally defined (AvailableExternally linkage) value by /// name. - pub(crate) fn get_defined_value(&self, name: &str) -> Option<&'ll Value> { + pub(crate) fn get_defined_value(&self, name: &str) -> Option> { self.get_declared_value(name).and_then(|val| { let declaration = llvm::is_declaration(val); if !declaration { Some(val) } else { None } diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs index d163b7304fbdd..c499cfc811a22 100644 --- a/compiler/rustc_codegen_llvm/src/intrinsic.rs +++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs @@ -51,8 +51,8 @@ use crate::va_arg::emit_va_arg; fn call_simple_intrinsic<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, name: Symbol, - args: &[OperandRef<'tcx, &'ll Value>], -) -> Option<&'ll Value> { + args: &[OperandRef<'tcx, Value<'ll>>], +) -> Option> { let llvm_version = crate::llvm_util::get_version(); // minimum/maximum were broken for f64/f128 before // . @@ -85,7 +85,7 @@ fn call_simple_intrinsic<'ll, 'tcx>( } impl<'ll, 'tcx> Builder<'_, 'll, 'tcx> { - fn black_box(&mut self, result: PlaceRef<'tcx, &'ll Value>, span: Span) { + fn black_box(&mut self, result: PlaceRef<'tcx, Value<'ll>>, span: Span) { let result_val_span = [result.val.llval]; // We need to "use" the argument in some way LLVM can't introspect, and on // targets that support it we can typically leverage inline assembly to do @@ -124,11 +124,11 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> { fn codegen_intrinsic_call( &mut self, instance: ty::Instance<'tcx>, - args: &[OperandRef<'tcx, &'ll Value>], + args: &[OperandRef<'tcx, Value<'ll>>], result_layout: ty::layout::TyAndLayout<'tcx>, - result_place: Option>, + result_place: Option>>, span: Span, - ) -> IntrinsicResult<'tcx, &'ll Value> { + ) -> IntrinsicResult<'tcx, Value<'ll>> { let tcx = self.tcx; let llvm_version = crate::llvm_util::get_version(); @@ -209,7 +209,7 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> { assert_eq!(args[1].layout, args[2].layout); let select = |bx: &mut Self, true_val, false_val| { let result = bx.select(cond, true_val, false_val); - bx.set_unpredictable(&result); + bx.set_unpredictable(result); result }; match (args[1].val, args[2].val) { @@ -952,13 +952,13 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> { debug!("call intrinsic {:?} with args ({:?})", instance, llargs); for (dest_ty, arg) in iter::zip(self.func_params_types(fn_ty), &mut llargs) { - let src_ty = self.val_ty(arg); + let src_ty = self.val_ty(*arg); assert!( can_autocast(self, src_ty, dest_ty), "Cannot match `{dest_ty:?}` (expected) with {src_ty:?} (found) in `{fn_ptr:?}" ); - *arg = autocast(self, arg, src_ty, dest_ty); + *arg = autocast(self, *arg, src_ty, dest_ty); } let llret = unsafe { @@ -1013,7 +1013,7 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> { fn type_checked_load( &mut self, - llvtable: &'ll Value, + llvtable: Value<'ll>, vtable_byte_offset: u64, typeid: &[u8], ) -> Self::Value { @@ -1028,7 +1028,7 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> { self.extract_value(type_checked_load, 0) } - fn va_start(&mut self, va_list: &'ll Value) { + fn va_start(&mut self, va_list: Value<'ll>) { self.call_intrinsic("llvm.va_start", &[self.val_ty(va_list)], &[va_list]); } @@ -1119,10 +1119,10 @@ fn can_autocast<'ll>(cx: &CodegenCx<'ll, '_>, rust_ty: Type<'ll>, llvm_ty: Type< fn autocast<'ll>( bx: &mut Builder<'_, 'll, '_>, - val: &'ll Value, + val: Value<'ll>, src_ty: Type<'ll>, dest_ty: Type<'ll>, -) -> &'ll Value { +) -> Value<'ll> { if src_ty == dest_ty { return val; } @@ -1202,7 +1202,7 @@ fn intrinsic_fn<'ll, 'tcx>( rust_return_ty: Type<'ll>, rust_argument_tys: Vec>, instance: ty::Instance<'tcx>, -) -> &'ll Value { +) -> Value<'ll> { let tcx = bx.tcx; let rust_fn_ty = bx.type_func(&rust_argument_tys, rust_return_ty); @@ -1301,10 +1301,10 @@ fn intrinsic_fn<'ll, 'tcx>( fn catch_unwind_intrinsic<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - try_func: &'ll Value, - data: &'ll Value, - catch_func: &'ll Value, -) -> &'ll Value { + try_func: Value<'ll>, + data: Value<'ll>, + catch_func: Value<'ll>, +) -> Value<'ll> { if !bx.sess().panic_strategy().unwinds() { let try_func_ty = bx.type_func(&[bx.type_ptr()], bx.type_void()); bx.call(try_func_ty, None, None, try_func, ReturnSlot::Direct, &[data], None, None); @@ -1329,10 +1329,10 @@ fn catch_unwind_intrinsic<'ll, 'tcx>( // as the old ones are still more optimized. fn codegen_msvc_try<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - try_func: &'ll Value, - data: &'ll Value, - catch_func: &'ll Value, -) -> &'ll Value { + try_func: Value<'ll>, + data: Value<'ll>, + catch_func: Value<'ll>, +) -> Value<'ll> { let (llty, llfn) = get_rust_try_fn(bx, &mut |mut bx| { bx.set_personality_fn(bx.eh_personality()); @@ -1515,10 +1515,10 @@ fn codegen_msvc_try<'ll, 'tcx>( // WASM's definition of the `rust_try` function. fn codegen_wasm_try<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - try_func: &'ll Value, - data: &'ll Value, - catch_func: &'ll Value, -) -> &'ll Value { + try_func: Value<'ll>, + data: Value<'ll>, + catch_func: Value<'ll>, +) -> Value<'ll> { let (llty, llfn) = get_rust_try_fn(bx, &mut |mut bx| { bx.set_personality_fn(bx.eh_personality()); @@ -1626,10 +1626,10 @@ fn codegen_wasm_try<'ll, 'tcx>( // the right personality function. fn codegen_gnu_try<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - try_func: &'ll Value, - data: &'ll Value, - catch_func: &'ll Value, -) -> &'ll Value { + try_func: Value<'ll>, + data: Value<'ll>, + catch_func: Value<'ll>, +) -> Value<'ll> { let (llty, llfn) = get_rust_try_fn(bx, &mut |mut bx| { // Codegens the shims described above: // @@ -1705,7 +1705,7 @@ fn gen_fn<'a, 'll, 'tcx>( name: &str, rust_fn_sig: ty::PolyFnSig<'tcx>, codegen: &mut dyn FnMut(Builder<'a, 'll, 'tcx>), -) -> (Type<'ll>, &'ll Value) { +) -> (Type<'ll>, Value<'ll>) { let fn_abi = cx.fn_abi_of_fn_ptr(rust_fn_sig, ty::List::empty()); let llty = fn_abi.llvm_type(cx); let llfn = cx.declare_fn(name, fn_abi, None); @@ -1727,7 +1727,7 @@ fn gen_fn<'a, 'll, 'tcx>( fn get_rust_try_fn<'a, 'll, 'tcx>( cx: &'a CodegenCx<'ll, 'tcx>, codegen: &mut dyn FnMut(Builder<'a, 'll, 'tcx>), -) -> (Type<'ll>, &'ll Value) { +) -> (Type<'ll>, Value<'ll>) { if let Some(llfn) = cx.rust_try_fn.get() { return llfn; } @@ -1769,9 +1769,9 @@ fn get_rust_try_fn<'a, 'll, 'tcx>( fn codegen_retag_inner<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, name: &'static str, - ptr: &'ll Value, - info: &RetagInfo<&'ll Value>, -) -> &'ll Value { + ptr: Value<'ll>, + info: &RetagInfo>, +) -> Value<'ll> { let size = bx.const_usize(info.size.bytes()); let perms = bx.const_u8(info.flags.bits()); @@ -1787,10 +1787,10 @@ fn codegen_retag_inner<'ll, 'tcx>( fn codegen_autodiff<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, instance: ty::Instance<'tcx>, - args: &[OperandRef<'tcx, &'ll Value>], + args: &[OperandRef<'tcx, Value<'ll>>], result_layout: ty::layout::TyAndLayout<'tcx>, - result_place: Option>, -) -> IntrinsicResult<'tcx, &'ll Value> { + result_place: Option>>, +) -> IntrinsicResult<'tcx, Value<'ll>> { let tcx = bx.tcx; if !tcx.sess.opts.unstable_opts.autodiff.contains(&rustc_session::config::AutoDiff::Enable) { let _ = tcx.dcx().emit_err(AutoDiffWithoutEnable); @@ -1877,7 +1877,7 @@ fn codegen_offload<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, tcx: TyCtxt<'tcx>, instance: ty::Instance<'tcx>, - args: &[OperandRef<'tcx, &'ll Value>], + args: &[OperandRef<'tcx, Value<'ll>>], ) { let cx = bx.cx; let fn_args = instance.args; @@ -1949,16 +1949,16 @@ fn codegen_offload<'ll, 'tcx>( &metadata, offload_globals, &offload_dims, - &dyn_cache, - &device_id, + dyn_cache, + device_id, ); } fn get_args_from_tuple<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - tuple_op: OperandRef<'tcx, &'ll Value>, + tuple_op: OperandRef<'tcx, Value<'ll>>, fn_instance: Instance<'tcx>, -) -> Vec<&'ll Value> { +) -> Vec> { let cx = bx.cx; let fn_abi = cx.fn_abi_of_instance(fn_instance, ty::List::empty()); @@ -2011,11 +2011,11 @@ fn generic_simd_intrinsic<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, name: Symbol, fn_args: GenericArgs<'tcx>, - args: &[OperandRef<'tcx, &'ll Value>], + args: &[OperandRef<'tcx, Value<'ll>>], ret_ty: Ty<'tcx>, llret_ty: Type<'ll>, span: Span, -) -> Result<&'ll Value, ErrorGuaranteed> { +) -> Result, ErrorGuaranteed> { macro_rules! return_error { ($diag: expr) => {{ let err = bx.sess().dcx().emit_err($diag); @@ -2087,10 +2087,10 @@ fn generic_simd_intrinsic<'ll, 'tcx>( /// efficiently converted to an all ones / all zeroes mask by comparing whether each element is negative. fn vector_mask_to_bitmask<'a, 'll, 'tcx>( bx: &mut Builder<'a, 'll, 'tcx>, - i_xn: &'ll Value, + i_xn: Value<'ll>, in_elem_bitwidth: u64, in_len: u64, - ) -> &'ll Value { + ) -> Value<'ll> { // Shift the MSB to the right by "in_elem_bitwidth - 1" into the first bit position. let shift_idx = bx.cx.const_int(bx.type_ix(in_elem_bitwidth), (in_elem_bitwidth - 1) as _); let shift_indices = vec![shift_idx; in_len as _]; @@ -2463,8 +2463,8 @@ fn generic_simd_intrinsic<'ll, 'tcx>( in_len: u64, bx: &mut Builder<'_, 'll, 'tcx>, span: Span, - args: &[OperandRef<'tcx, &'ll Value>], - ) -> Result<&'ll Value, ErrorGuaranteed> { + args: &[OperandRef<'tcx, Value<'ll>>], + ) -> Result, ErrorGuaranteed> { macro_rules! return_error { ($diag: expr) => {{ let err = bx.sess().dcx().emit_err($diag); diff --git a/compiler/rustc_codegen_llvm/src/llvm/diagnostic.rs b/compiler/rustc_codegen_llvm/src/llvm/diagnostic.rs index 978a718cda590..8060308b5d34e 100644 --- a/compiler/rustc_codegen_llvm/src/llvm/diagnostic.rs +++ b/compiler/rustc_codegen_llvm/src/llvm/diagnostic.rs @@ -23,7 +23,7 @@ pub(crate) struct OptimizationDiagnostic<'ll> { pub kind: OptimizationDiagnosticKind, pub pass_name: String, #[expect(dead_code)] - pub function: &'ll Value, + pub function: Value<'ll>, pub line: c_uint, pub column: c_uint, pub filename: String, diff --git a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs index 549cf5be70387..46edf657a4d24 100644 --- a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs +++ b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs @@ -36,53 +36,60 @@ pub(crate) struct TypeTree { #[link(name = "llvm-wrapper", kind = "static")] unsafe extern "C" { // Enzyme - pub(crate) safe fn LLVMRustHasMetadata(I: &Value, KindID: MetadataKindId) -> bool; - pub(crate) fn LLVMRustEraseInstUntilInclusive(BB: &BasicBlock, I: &Value); - pub(crate) fn LLVMRustGetLastInstruction<'a>(BB: &BasicBlock) -> Option<&'a Value>; - pub(crate) fn LLVMRustDIGetInstMetadata(I: &Value) -> Option<&Metadata>; - pub(crate) fn LLVMRustEraseInstFromParent(V: &Value); - pub(crate) fn LLVMRustGetTerminator<'a>(B: &BasicBlock) -> &'a Value; - pub(crate) fn LLVMRustVerifyFunction(V: &Value, action: LLVMRustVerifierFailureAction) -> Bool; - pub(crate) fn LLVMRustHasAttributeAtIndex(V: &Value, i: c_uint, Kind: AttributeKind) -> bool; + pub(crate) safe fn LLVMRustHasMetadata<'ll>(I: Value<'ll>, KindID: MetadataKindId) -> bool; + pub(crate) fn LLVMRustEraseInstUntilInclusive<'ll>(BB: &'ll BasicBlock, I: Value<'ll>); + pub(crate) fn LLVMRustGetLastInstruction<'ll>(BB: &'ll BasicBlock) -> Option>; + pub(crate) fn LLVMRustDIGetInstMetadata<'ll>(I: Value<'ll>) -> Option<&'ll Metadata>; + pub(crate) fn LLVMRustEraseInstFromParent<'ll>(V: Value<'ll>); + pub(crate) fn LLVMRustGetTerminator<'ll>(B: &'ll BasicBlock) -> Value<'ll>; + pub(crate) fn LLVMRustVerifyFunction<'ll>( + V: Value<'ll>, + action: LLVMRustVerifierFailureAction, + ) -> Bool; + pub(crate) fn LLVMRustHasAttributeAtIndex<'ll>( + V: Value<'ll>, + i: c_uint, + Kind: AttributeKind, + ) -> bool; pub(crate) fn LLVMRustGetArrayNumElements<'ll>(Ty: Type<'ll>) -> u64; - pub(crate) fn LLVMRustHasFnAttribute( - F: &Value, + pub(crate) fn LLVMRustHasFnAttribute<'ll>( + F: Value<'ll>, Name: *const c_uchar, // See "PTR_LEN_STR". NameLen: libc::size_t, ) -> bool; - pub(crate) fn LLVMRustRemoveFnAttribute( - F: &Value, + pub(crate) fn LLVMRustRemoveFnAttribute<'ll>( + F: Value<'ll>, Name: *const c_uchar, // See "PTR_LEN_STR". NameLen: libc::size_t, ); - pub(crate) fn LLVMGetFirstFunction<'ll>(M: Module<'ll>) -> Option<&'ll Value>; - pub(crate) fn LLVMGetNextFunction(Fn: &Value) -> Option<&Value>; - pub(crate) fn LLVMRustRemoveEnumAttributeAtIndex( - Fn: &Value, + pub(crate) fn LLVMGetFirstFunction<'ll>(M: Module<'ll>) -> Option>; + pub(crate) fn LLVMGetNextFunction<'ll>(Fn: Value<'ll>) -> Option>; + pub(crate) fn LLVMRustRemoveEnumAttributeAtIndex<'ll>( + Fn: Value<'ll>, index: c_uint, kind: AttributeKind, ); - pub(crate) fn LLVMRustPositionBefore<'a>(B: &'a Builder<'_>, I: &'a Value); - pub(crate) fn LLVMRustPositionAfter<'a>(B: &'a Builder<'_>, I: &'a Value); - pub(crate) fn LLVMRustGetFunctionCall( - F: &Value, + pub(crate) fn LLVMRustPositionBefore<'ll>(B: &Builder<'ll>, I: Value<'ll>); + pub(crate) fn LLVMRustPositionAfter<'ll>(B: &Builder<'ll>, I: Value<'ll>); + pub(crate) fn LLVMRustGetFunctionCall<'ll>( + F: Value<'ll>, name: *const c_char, NameLen: libc::size_t, - ) -> Option<&Value>; + ) -> Option>; - pub(crate) safe fn LLVMRustIsCall(V: &Value) -> bool; + pub(crate) safe fn LLVMRustIsCall<'ll>(V: Value<'ll>) -> bool; } unsafe extern "C" { // Enzyme pub(crate) fn LLVMDumpModule<'ll>(M: Module<'ll>); - pub(crate) fn LLVMDumpValue(V: &Value); - pub(crate) fn LLVMGetFunctionCallConv(F: &Value) -> c_uint; - pub(crate) fn LLVMGetParams(Fnc: &Value, params: *mut &Value); + pub(crate) fn LLVMDumpValue<'ll>(V: Value<'ll>); + pub(crate) fn LLVMGetFunctionCallConv<'ll>(F: Value<'ll>) -> c_uint; + pub(crate) fn LLVMGetParams<'ll>(Fnc: Value<'ll>, params: *mut Value<'ll>); pub(crate) fn LLVMGetNamedFunction<'ll>( M: Module<'ll>, Name: *const c_char, - ) -> Option<&'ll Value>; + ) -> Option>; } #[repr(C)] diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs index 11b276f565d4b..c53dfe6fe5d05 100644 --- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs +++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs @@ -21,7 +21,7 @@ use bitflags::bitflags; use libc::{c_char, c_int, c_uchar, c_uint, c_ulonglong, c_void, size_t}; pub(crate) use self::branded::{ - Context, ContextRaw, Module, ModuleRaw, Type, wrap_llcx, wrap_llmod, + Context, ContextRaw, Module, ModuleRaw, Type, Value, wrap_llcx, wrap_llmod, }; use super::RustString; use super::debuginfo::{ @@ -707,7 +707,6 @@ struct InvariantOpaque<'a> { // Opaque pointer types unsafe extern "C" { - pub(crate) type Value; pub(crate) type ConstantInt; pub(crate) type Attribute; pub(crate) type Metadata; @@ -929,7 +928,7 @@ unsafe extern "C" { IsAlignStack: llvm::Bool, Dialect: AsmDialect, CanThrow: llvm::Bool, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) safe fn LLVMGetTypeKind<'ll>(Ty: Type<'ll>) -> RawEnum; @@ -992,35 +991,39 @@ unsafe extern "C" { pub(crate) fn LLVMVoidTypeInContext<'ll>(C: Context<'ll>) -> Type<'ll>; // Operations on all values - pub(crate) fn LLVMTypeOf<'ll>(Val: &'ll Value) -> Type<'ll>; - pub(crate) fn LLVMGetValueName2(Val: &Value, Length: *mut size_t) -> *const c_char; - pub(crate) fn LLVMSetValueName2( - Val: &Value, + pub(crate) fn LLVMTypeOf<'ll>(Val: Value<'ll>) -> Type<'ll>; + pub(crate) fn LLVMGetValueName2<'ll>(Val: Value<'ll>, Length: *mut size_t) -> *const c_char; + pub(crate) fn LLVMSetValueName2<'ll>( + Val: Value<'ll>, Name: *const c_uchar, // See "PTR_LEN_STR". NameLen: size_t, ); - pub(crate) fn LLVMReplaceAllUsesWith<'a>(OldVal: &'a Value, NewVal: &'a Value); - pub(crate) safe fn LLVMGetMetadata<'a>( - Val: &'a Value, + pub(crate) fn LLVMReplaceAllUsesWith<'ll>(OldVal: Value<'ll>, NewVal: Value<'ll>); + pub(crate) safe fn LLVMGetMetadata<'ll>( + Val: Value<'ll>, KindID: MetadataKindId, - ) -> Option<&'a Value>; - pub(crate) safe fn LLVMSetMetadata<'a>(Val: &'a Value, KindID: MetadataKindId, Node: &'a Value); - pub(crate) fn LLVMGlobalSetMetadata<'a>( - Val: &'a Value, + ) -> Option>; + pub(crate) safe fn LLVMSetMetadata<'ll>( + Val: Value<'ll>, KindID: MetadataKindId, - Metadata: &'a Metadata, + Node: Value<'ll>, + ); + pub(crate) fn LLVMGlobalSetMetadata<'ll>( + Val: Value<'ll>, + KindID: MetadataKindId, + Metadata: &'ll Metadata, ); pub(crate) fn LLVMGlobalAddMetadata<'ll>( - Global: &'ll Value, + Global: Value<'ll>, Kind: MetadataKindId, MD: &'ll Metadata, ); - pub(crate) safe fn LLVMValueAsMetadata(Node: &Value) -> &Metadata; + pub(crate) safe fn LLVMValueAsMetadata<'ll>(Node: Value<'ll>) -> &'ll Metadata; // Operations on constants of any type - pub(crate) fn LLVMConstNull<'ll>(Ty: Type<'ll>) -> &'ll Value; - pub(crate) fn LLVMGetUndef<'ll>(Ty: Type<'ll>) -> &'ll Value; - pub(crate) fn LLVMGetPoison<'ll>(Ty: Type<'ll>) -> &'ll Value; + pub(crate) fn LLVMConstNull<'ll>(Ty: Type<'ll>) -> Value<'ll>; + pub(crate) fn LLVMGetUndef<'ll>(Ty: Type<'ll>) -> Value<'ll>; + pub(crate) fn LLVMGetPoison<'ll>(Ty: Type<'ll>) -> Value<'ll>; // Operations on metadata pub(crate) fn LLVMMDStringInContext2<'ll>( @@ -1036,113 +1039,123 @@ unsafe extern "C" { pub(crate) fn LLVMAddNamedMetadataOperand<'ll>( M: Module<'ll>, Name: *const c_char, - Val: &'ll Value, + Val: Value<'ll>, + ); + pub(crate) fn LLVMReplaceMDNodeOperandWith<'ll>( + Val: Value<'ll>, + index: u32, + replacement: &'ll Metadata, ); - pub(crate) fn LLVMReplaceMDNodeOperandWith(Val: &Value, index: u32, replacement: &Metadata); // Operations on scalar constants pub(crate) fn LLVMConstInt<'ll>( IntTy: Type<'ll>, N: c_ulonglong, SignExtend: Bool, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMConstIntOfArbitraryPrecision<'ll>( IntTy: Type<'ll>, Wn: c_uint, Ws: *const u64, - ) -> &'ll Value; - pub(crate) fn LLVMConstReal<'ll>(RealTy: Type<'ll>, N: f64) -> &'ll Value; + ) -> Value<'ll>; + pub(crate) fn LLVMConstReal<'ll>(RealTy: Type<'ll>, N: f64) -> Value<'ll>; // Operations on composite constants pub(crate) fn LLVMConstArray2<'ll>( ElementTy: Type<'ll>, - ConstantVals: *const &'ll Value, + ConstantVals: *const Value<'ll>, Length: u64, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMArrayType2<'ll>(ElementType: Type<'ll>, ElementCount: u64) -> Type<'ll>; pub(crate) fn LLVMConstStringInContext2<'ll>( C: Context<'ll>, Str: *const c_uchar, // See "PTR_LEN_STR". Length: size_t, DontNullTerminate: Bool, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMConstStructInContext<'ll>( C: Context<'ll>, - ConstantVals: *const &'ll Value, + ConstantVals: *const Value<'ll>, Count: c_uint, Packed: Bool, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMConstNamedStruct<'ll>( StructTy: Type<'ll>, - ConstantVals: *const &'ll Value, + ConstantVals: *const Value<'ll>, Count: c_uint, - ) -> &'ll Value; - pub(crate) fn LLVMConstVector(ScalarConstantVals: *const &Value, Size: c_uint) -> &Value; + ) -> Value<'ll>; + pub(crate) fn LLVMConstVector<'ll>( + ScalarConstantVals: *const Value<'ll>, + Size: c_uint, + ) -> Value<'ll>; // Constant expressions pub(crate) fn LLVMConstInBoundsGEP2<'ll>( ty: Type<'ll>, - ConstantVal: &'ll Value, - ConstantIndices: *const &'ll Value, + ConstantVal: Value<'ll>, + ConstantIndices: *const Value<'ll>, NumIndices: c_uint, - ) -> &'ll Value; - pub(crate) fn LLVMConstPtrToInt<'ll>(ConstantVal: &'ll Value, ToType: Type<'ll>) -> &'ll Value; - pub(crate) fn LLVMConstIntToPtr<'ll>(ConstantVal: &'ll Value, ToType: Type<'ll>) -> &'ll Value; - pub(crate) fn LLVMConstBitCast<'ll>(ConstantVal: &'ll Value, ToType: Type<'ll>) -> &'ll Value; + ) -> Value<'ll>; + pub(crate) fn LLVMConstPtrToInt<'ll>(ConstantVal: Value<'ll>, ToType: Type<'ll>) -> Value<'ll>; + pub(crate) fn LLVMConstIntToPtr<'ll>(ConstantVal: Value<'ll>, ToType: Type<'ll>) -> Value<'ll>; + pub(crate) fn LLVMConstBitCast<'ll>(ConstantVal: Value<'ll>, ToType: Type<'ll>) -> Value<'ll>; pub(crate) fn LLVMConstPointerCast<'ll>( - ConstantVal: &'ll Value, + ConstantVal: Value<'ll>, ToType: Type<'ll>, - ) -> &'ll Value; - pub(crate) fn LLVMGetAggregateElement(ConstantVal: &Value, Idx: c_uint) -> Option<&Value>; - pub(crate) fn LLVMGetConstOpcode(ConstantVal: &Value) -> Opcode; - pub(crate) fn LLVMIsAConstantExpr(Val: &Value) -> Option<&Value>; + ) -> Value<'ll>; + pub(crate) fn LLVMGetAggregateElement<'ll>( + ConstantVal: Value<'ll>, + Idx: c_uint, + ) -> Option>; + pub(crate) fn LLVMGetConstOpcode<'ll>(ConstantVal: Value<'ll>) -> Opcode; + pub(crate) fn LLVMIsAConstantExpr<'ll>(Val: Value<'ll>) -> Option>; // Operations on global variables, functions, and aliases (globals) - pub(crate) fn LLVMIsDeclaration(Global: &Value) -> Bool; - pub(crate) fn LLVMGetLinkage(Global: &Value) -> RawEnum; - pub(crate) fn LLVMSetLinkage(Global: &Value, RustLinkage: Linkage); - pub(crate) fn LLVMSetSection(Global: &Value, Section: *const c_char); - pub(crate) fn LLVMGetVisibility(Global: &Value) -> RawEnum; - pub(crate) fn LLVMSetVisibility(Global: &Value, Viz: Visibility); - pub(crate) fn LLVMGetAlignment(Global: &Value) -> c_uint; - pub(crate) fn LLVMSetAlignment(Global: &Value, Bytes: c_uint); - pub(crate) fn LLVMSetDLLStorageClass(V: &Value, C: DLLStorageClass); - pub(crate) fn LLVMGlobalGetValueType<'ll>(Global: &'ll Value) -> Type<'ll>; + pub(crate) fn LLVMIsDeclaration<'ll>(Global: Value<'ll>) -> Bool; + pub(crate) fn LLVMGetLinkage<'ll>(Global: Value<'ll>) -> RawEnum; + pub(crate) fn LLVMSetLinkage<'ll>(Global: Value<'ll>, RustLinkage: Linkage); + pub(crate) fn LLVMSetSection<'ll>(Global: Value<'ll>, Section: *const c_char); + pub(crate) fn LLVMGetVisibility<'ll>(Global: Value<'ll>) -> RawEnum; + pub(crate) fn LLVMSetVisibility<'ll>(Global: Value<'ll>, Viz: Visibility); + pub(crate) fn LLVMGetAlignment<'ll>(Global: Value<'ll>) -> c_uint; + pub(crate) fn LLVMSetAlignment<'ll>(Global: Value<'ll>, Bytes: c_uint); + pub(crate) fn LLVMSetDLLStorageClass<'ll>(V: Value<'ll>, C: DLLStorageClass); + pub(crate) fn LLVMGlobalGetValueType<'ll>(Global: Value<'ll>) -> Type<'ll>; // Operations on global variables - pub(crate) safe fn LLVMIsAGlobalVariable(GlobalVar: &Value) -> Option<&Value>; + pub(crate) safe fn LLVMIsAGlobalVariable<'ll>(GlobalVar: Value<'ll>) -> Option>; pub(crate) fn LLVMAddGlobal<'ll>( M: Module<'ll>, Ty: Type<'ll>, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMGetNamedGlobal<'ll>( M: Module<'ll>, Name: *const c_char, - ) -> Option<&'ll Value>; - pub(crate) fn LLVMGetFirstGlobal<'ll>(M: Module<'ll>) -> Option<&'ll Value>; - pub(crate) fn LLVMGetNextGlobal(GlobalVar: &Value) -> Option<&Value>; - pub(crate) fn LLVMDeleteGlobal(GlobalVar: &Value); - pub(crate) safe fn LLVMGetInitializer(GlobalVar: &Value) -> Option<&Value>; - pub(crate) fn LLVMSetInitializer<'a>(GlobalVar: &'a Value, ConstantVal: &'a Value); - pub(crate) safe fn LLVMIsThreadLocal(GlobalVar: &Value) -> Bool; - pub(crate) fn LLVMSetThreadLocalMode(GlobalVar: &Value, Mode: ThreadLocalMode); - pub(crate) safe fn LLVMIsGlobalConstant(GlobalVar: &Value) -> Bool; - pub(crate) safe fn LLVMSetGlobalConstant(GlobalVar: &Value, IsConstant: Bool); - pub(crate) safe fn LLVMSetTailCall(CallInst: &Value, IsTailCall: Bool); - pub(crate) safe fn LLVMSetTailCallKind(CallInst: &Value, kind: TailCallKind); - pub(crate) safe fn LLVMSetExternallyInitialized(GlobalVar: &Value, IsExtInit: Bool); + ) -> Option>; + pub(crate) fn LLVMGetFirstGlobal<'ll>(M: Module<'ll>) -> Option>; + pub(crate) fn LLVMGetNextGlobal<'ll>(GlobalVar: Value<'ll>) -> Option>; + pub(crate) fn LLVMDeleteGlobal<'ll>(GlobalVar: Value<'ll>); + pub(crate) safe fn LLVMGetInitializer<'ll>(GlobalVar: Value<'ll>) -> Option>; + pub(crate) fn LLVMSetInitializer<'ll>(GlobalVar: Value<'ll>, ConstantVal: Value<'ll>); + pub(crate) safe fn LLVMIsThreadLocal<'ll>(GlobalVar: Value<'ll>) -> Bool; + pub(crate) fn LLVMSetThreadLocalMode<'ll>(GlobalVar: Value<'ll>, Mode: ThreadLocalMode); + pub(crate) safe fn LLVMIsGlobalConstant<'ll>(GlobalVar: Value<'ll>) -> Bool; + pub(crate) safe fn LLVMSetGlobalConstant<'ll>(GlobalVar: Value<'ll>, IsConstant: Bool); + pub(crate) safe fn LLVMSetTailCall<'ll>(CallInst: Value<'ll>, IsTailCall: Bool); + pub(crate) safe fn LLVMSetTailCallKind<'ll>(CallInst: Value<'ll>, kind: TailCallKind); + pub(crate) safe fn LLVMSetExternallyInitialized<'ll>(GlobalVar: Value<'ll>, IsExtInit: Bool); // Operations on global aliases pub(crate) fn LLVMAddAlias2<'ll>( M: Module<'ll>, ValueTy: Type<'ll>, AddressSpace: c_uint, - Aliasee: &Value, + Aliasee: Value<'ll>, Name: *const c_char, - ) -> &'ll Value; - pub(crate) fn LLVMGetFirstGlobalAlias<'ll>(M: Module<'ll>) -> Option<&'ll Value>; - pub(crate) fn LLVMGetNextGlobalAlias(GlobalAlias: &Value) -> Option<&Value>; + ) -> Value<'ll>; + pub(crate) fn LLVMGetFirstGlobalAlias<'ll>(M: Module<'ll>) -> Option>; + pub(crate) fn LLVMGetNextGlobalAlias<'ll>(GlobalAlias: Value<'ll>) -> Option>; // Operations on attributes pub(crate) fn LLVMCreateStringAttribute<'ll>( @@ -1154,19 +1167,19 @@ unsafe extern "C" { ) -> &'ll Attribute; // Operations on functions - pub(crate) fn LLVMSetFunctionCallConv(Fn: &Value, CC: c_uint); + pub(crate) fn LLVMSetFunctionCallConv<'ll>(Fn: Value<'ll>, CC: c_uint); pub(crate) fn LLVMAddFunction<'ll>( Mod: Module<'ll>, Name: *const c_char, FunctionTy: Type<'ll>, - ) -> &'ll Value; - pub(crate) fn LLVMDeleteFunction(Fn: &Value); + ) -> Value<'ll>; + pub(crate) fn LLVMDeleteFunction<'ll>(Fn: Value<'ll>); pub(crate) fn LLVMGetOrInsertFunction<'ll>( M: Module<'ll>, Name: *const c_uchar, // See "PTR_LEN_STR". NameLen: size_t, FunctionTy: Type<'ll>, - ) -> &'ll Value; + ) -> Value<'ll>; // Operations about llvm intrinsics pub(crate) fn LLVMLookupIntrinsicID( @@ -1179,43 +1192,43 @@ unsafe extern "C" { ID: NonZero, ParamTypes: *const Type<'ll>, ParamCount: size_t, - ) -> &'ll Value; - pub(crate) fn LLVMRustUpgradeIntrinsicFunction<'a>( - Fn: &'a Value, - NewFn: &mut Option<&'a Value>, + ) -> Value<'ll>; + pub(crate) fn LLVMRustUpgradeIntrinsicFunction<'ll>( + Fn: Value<'ll>, + NewFn: &mut Option>, ) -> bool; pub(crate) fn LLVMRustIsTargetIntrinsic(ID: NonZero) -> bool; // Operations on parameters - pub(crate) fn LLVMIsAArgument(Val: &Value) -> Option<&Value>; - pub(crate) safe fn LLVMCountParams(Fn: &Value) -> c_uint; - pub(crate) fn LLVMGetParam(Fn: &Value, Index: c_uint) -> &Value; + pub(crate) fn LLVMIsAArgument<'ll>(Val: Value<'ll>) -> Option>; + pub(crate) safe fn LLVMCountParams<'ll>(Fn: Value<'ll>) -> c_uint; + pub(crate) fn LLVMGetParam<'ll>(Fn: Value<'ll>, Index: c_uint) -> Value<'ll>; // Operations on basic blocks - pub(crate) fn LLVMGetBasicBlockParent(BB: &BasicBlock) -> &Value; + pub(crate) fn LLVMGetBasicBlockParent<'ll>(BB: &'ll BasicBlock) -> Value<'ll>; pub(crate) fn LLVMAppendBasicBlockInContext<'ll>( C: Context<'ll>, - Fn: &'ll Value, + Fn: Value<'ll>, Name: *const c_char, ) -> &'ll BasicBlock; // Operations on instructions - pub(crate) fn LLVMIsAInstruction(Val: &Value) -> Option<&Value>; - pub(crate) fn LLVMGetFirstBasicBlock(Fn: &Value) -> &BasicBlock; - pub(crate) fn LLVMGetOperand(Val: &Value, Index: c_uint) -> Option<&Value>; + pub(crate) fn LLVMIsAInstruction<'ll>(Val: Value<'ll>) -> Option>; + pub(crate) fn LLVMGetFirstBasicBlock<'ll>(Fn: Value<'ll>) -> &'ll BasicBlock; + pub(crate) fn LLVMGetOperand<'ll>(Val: Value<'ll>, Index: c_uint) -> Option>; // Operations on call sites - pub(crate) fn LLVMSetInstructionCallConv(Instr: &Value, CC: c_uint); + pub(crate) fn LLVMSetInstructionCallConv<'ll>(Instr: Value<'ll>, CC: c_uint); // Operations on load/store instructions (only) - pub(crate) fn LLVMSetVolatile(MemoryAccessInst: &Value, volatile: Bool); - pub(crate) fn LLVMSetOrdering(MemoryAccessInst: &Value, Ordering: AtomicOrdering); + pub(crate) fn LLVMSetVolatile<'ll>(MemoryAccessInst: Value<'ll>, volatile: Bool); + pub(crate) fn LLVMSetOrdering<'ll>(MemoryAccessInst: Value<'ll>, Ordering: AtomicOrdering); // Operations on phi nodes - pub(crate) fn LLVMAddIncoming<'a>( - PhiNode: &'a Value, - IncomingValues: *const &'a Value, - IncomingBlocks: *const &'a BasicBlock, + pub(crate) fn LLVMAddIncoming<'ll>( + PhiNode: Value<'ll>, + IncomingValues: *const Value<'ll>, + IncomingBlocks: *const &'ll BasicBlock, Count: c_uint, ); @@ -1230,455 +1243,465 @@ unsafe extern "C" { pub(crate) fn LLVMGetCurrentDebugLocation2<'a>(Builder: &Builder<'a>) -> Option<&'a Metadata>; // Terminators - pub(crate) safe fn LLVMBuildRetVoid<'a>(B: &Builder<'a>) -> &'a Value; - pub(crate) fn LLVMBuildRet<'a>(B: &Builder<'a>, V: &'a Value) -> &'a Value; - pub(crate) fn LLVMBuildBr<'a>(B: &Builder<'a>, Dest: &'a BasicBlock) -> &'a Value; - pub(crate) fn LLVMBuildCondBr<'a>( - B: &Builder<'a>, - If: &'a Value, - Then: &'a BasicBlock, - Else: &'a BasicBlock, - ) -> &'a Value; - pub(crate) fn LLVMBuildSwitch<'a>( - B: &Builder<'a>, - V: &'a Value, - Else: &'a BasicBlock, + pub(crate) safe fn LLVMBuildRetVoid<'ll>(B: &Builder<'ll>) -> Value<'ll>; + pub(crate) fn LLVMBuildRet<'ll>(B: &Builder<'ll>, V: Value<'ll>) -> Value<'ll>; + pub(crate) fn LLVMBuildBr<'ll>(B: &Builder<'ll>, Dest: &'ll BasicBlock) -> Value<'ll>; + pub(crate) fn LLVMBuildCondBr<'ll>( + B: &Builder<'ll>, + If: Value<'ll>, + Then: &'ll BasicBlock, + Else: &'ll BasicBlock, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildSwitch<'ll>( + B: &Builder<'ll>, + V: Value<'ll>, + Else: &'ll BasicBlock, NumCases: c_uint, - ) -> &'a Value; + ) -> Value<'ll>; pub(crate) fn LLVMBuildLandingPad<'ll>( B: &Builder<'ll>, Ty: Type<'ll>, - PersFn: Option<&'ll Value>, + PersFn: Option>, NumClauses: c_uint, Name: *const c_char, - ) -> &'ll Value; - pub(crate) fn LLVMBuildResume<'a>(B: &Builder<'a>, Exn: &'a Value) -> &'a Value; - pub(crate) fn LLVMBuildUnreachable<'a>(B: &Builder<'a>) -> &'a Value; + ) -> Value<'ll>; + pub(crate) fn LLVMBuildResume<'ll>(B: &Builder<'ll>, Exn: Value<'ll>) -> Value<'ll>; + pub(crate) fn LLVMBuildUnreachable<'ll>(B: &Builder<'ll>) -> Value<'ll>; - pub(crate) fn LLVMBuildCleanupPad<'a>( - B: &Builder<'a>, - ParentPad: Option<&'a Value>, - Args: *const &'a Value, + pub(crate) fn LLVMBuildCleanupPad<'ll>( + B: &Builder<'ll>, + ParentPad: Option>, + Args: *const Value<'ll>, NumArgs: c_uint, Name: *const c_char, - ) -> Option<&'a Value>; - pub(crate) fn LLVMBuildCleanupRet<'a>( - B: &Builder<'a>, - CleanupPad: &'a Value, - BB: Option<&'a BasicBlock>, - ) -> Option<&'a Value>; - pub(crate) fn LLVMBuildCatchPad<'a>( - B: &Builder<'a>, - ParentPad: &'a Value, - Args: *const &'a Value, + ) -> Option>; + pub(crate) fn LLVMBuildCleanupRet<'ll>( + B: &Builder<'ll>, + CleanupPad: Value<'ll>, + BB: Option<&'ll BasicBlock>, + ) -> Option>; + pub(crate) fn LLVMBuildCatchPad<'ll>( + B: &Builder<'ll>, + ParentPad: Value<'ll>, + Args: *const Value<'ll>, NumArgs: c_uint, Name: *const c_char, - ) -> Option<&'a Value>; - pub(crate) fn LLVMBuildCatchRet<'a>( - B: &Builder<'a>, - CatchPad: &'a Value, - BB: &'a BasicBlock, - ) -> Option<&'a Value>; - pub(crate) fn LLVMBuildCatchSwitch<'a>( - Builder: &Builder<'a>, - ParentPad: Option<&'a Value>, - UnwindBB: Option<&'a BasicBlock>, + ) -> Option>; + pub(crate) fn LLVMBuildCatchRet<'ll>( + B: &Builder<'ll>, + CatchPad: Value<'ll>, + BB: &'ll BasicBlock, + ) -> Option>; + pub(crate) fn LLVMBuildCatchSwitch<'ll>( + Builder: &Builder<'ll>, + ParentPad: Option>, + UnwindBB: Option<&'ll BasicBlock>, NumHandlers: c_uint, Name: *const c_char, - ) -> Option<&'a Value>; - pub(crate) fn LLVMAddHandler<'a>(CatchSwitch: &'a Value, Dest: &'a BasicBlock); - pub(crate) fn LLVMSetPersonalityFn<'a>(Func: &'a Value, Pers: &'a Value); + ) -> Option>; + pub(crate) fn LLVMAddHandler<'ll>(CatchSwitch: Value<'ll>, Dest: &'ll BasicBlock); + pub(crate) fn LLVMSetPersonalityFn<'ll>(Func: Value<'ll>, Pers: Value<'ll>); // Add a case to the switch instruction - pub(crate) fn LLVMAddCase<'a>(Switch: &'a Value, OnVal: &'a Value, Dest: &'a BasicBlock); + pub(crate) fn LLVMAddCase<'ll>(Switch: Value<'ll>, OnVal: Value<'ll>, Dest: &'ll BasicBlock); // Add a clause to the landing pad instruction - pub(crate) fn LLVMAddClause<'a>(LandingPad: &'a Value, ClauseVal: &'a Value); + pub(crate) fn LLVMAddClause<'ll>(LandingPad: Value<'ll>, ClauseVal: Value<'ll>); // Set the cleanup on a landing pad instruction - pub(crate) fn LLVMSetCleanup(LandingPad: &Value, Val: Bool); + pub(crate) fn LLVMSetCleanup<'ll>(LandingPad: Value<'ll>, Val: Bool); // Arithmetic - pub(crate) fn LLVMBuildAdd<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildFAdd<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildSub<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildFSub<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildMul<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildFMul<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildUDiv<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildExactUDiv<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildSDiv<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildExactSDiv<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildFDiv<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildURem<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildSRem<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildFRem<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildShl<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildLShr<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildAShr<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildNSWAdd<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildNUWAdd<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildNSWSub<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildNUWSub<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildNSWMul<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildNUWMul<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildAnd<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildOr<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildXor<'a>( - B: &Builder<'a>, - LHS: &'a Value, - RHS: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildNeg<'a>(B: &Builder<'a>, V: &'a Value, Name: *const c_char) - -> &'a Value; - pub(crate) fn LLVMBuildFNeg<'a>( - B: &Builder<'a>, - V: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildNot<'a>(B: &Builder<'a>, V: &'a Value, Name: *const c_char) - -> &'a Value; + pub(crate) fn LLVMBuildAdd<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildFAdd<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildSub<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildFSub<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildMul<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildFMul<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildUDiv<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildExactUDiv<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildSDiv<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildExactSDiv<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildFDiv<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildURem<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildSRem<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildFRem<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildShl<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildLShr<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildAShr<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildNSWAdd<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildNUWAdd<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildNSWSub<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildNUWSub<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildNSWMul<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildNUWMul<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildAnd<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildOr<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildXor<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + RHS: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildNeg<'ll>( + B: &Builder<'ll>, + V: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildFNeg<'ll>( + B: &Builder<'ll>, + V: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildNot<'ll>( + B: &Builder<'ll>, + V: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; // Extra flags on arithmetic - pub(crate) fn LLVMSetIsDisjoint(Instr: &Value, IsDisjoint: Bool); - pub(crate) fn LLVMSetNUW(ArithInst: &Value, HasNUW: Bool); - pub(crate) fn LLVMSetNSW(ArithInst: &Value, HasNSW: Bool); + pub(crate) fn LLVMSetIsDisjoint<'ll>(Instr: Value<'ll>, IsDisjoint: Bool); + pub(crate) fn LLVMSetNUW<'ll>(ArithInst: Value<'ll>, HasNUW: Bool); + pub(crate) fn LLVMSetNSW<'ll>(ArithInst: Value<'ll>, HasNSW: Bool); // Memory pub(crate) fn LLVMBuildAlloca<'ll>( B: &Builder<'ll>, Ty: Type<'ll>, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMBuildLoad2<'ll>( B: &Builder<'ll>, Ty: Type<'ll>, - PointerVal: &'ll Value, + PointerVal: Value<'ll>, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; - pub(crate) fn LLVMBuildStore<'a>(B: &Builder<'a>, Val: &'a Value, Ptr: &'a Value) -> &'a Value; + pub(crate) fn LLVMBuildStore<'ll>( + B: &Builder<'ll>, + Val: Value<'ll>, + Ptr: Value<'ll>, + ) -> Value<'ll>; pub(crate) fn LLVMBuildGEPWithNoWrapFlags<'ll>( B: &Builder<'ll>, Ty: Type<'ll>, - Pointer: &'ll Value, - Indices: *const &'ll Value, + Pointer: Value<'ll>, + Indices: *const Value<'ll>, NumIndices: c_uint, Name: *const c_char, Flags: GEPNoWrapFlags, - ) -> &'ll Value; + ) -> Value<'ll>; // Casts pub(crate) fn LLVMBuildTrunc<'ll>( B: &Builder<'ll>, - Val: &'ll Value, + Val: Value<'ll>, DestTy: Type<'ll>, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMBuildZExt<'ll>( B: &Builder<'ll>, - Val: &'ll Value, + Val: Value<'ll>, DestTy: Type<'ll>, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMBuildSExt<'ll>( B: &Builder<'ll>, - Val: &'ll Value, + Val: Value<'ll>, DestTy: Type<'ll>, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMBuildFPToUI<'ll>( B: &Builder<'ll>, - Val: &'ll Value, + Val: Value<'ll>, DestTy: Type<'ll>, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMBuildFPToSI<'ll>( B: &Builder<'ll>, - Val: &'ll Value, + Val: Value<'ll>, DestTy: Type<'ll>, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMBuildUIToFP<'ll>( B: &Builder<'ll>, - Val: &'ll Value, + Val: Value<'ll>, DestTy: Type<'ll>, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMBuildSIToFP<'ll>( B: &Builder<'ll>, - Val: &'ll Value, + Val: Value<'ll>, DestTy: Type<'ll>, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMBuildFPTrunc<'ll>( B: &Builder<'ll>, - Val: &'ll Value, + Val: Value<'ll>, DestTy: Type<'ll>, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMBuildFPExt<'ll>( B: &Builder<'ll>, - Val: &'ll Value, + Val: Value<'ll>, DestTy: Type<'ll>, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMBuildPtrToInt<'ll>( B: &Builder<'ll>, - Val: &'ll Value, + Val: Value<'ll>, DestTy: Type<'ll>, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMBuildIntToPtr<'ll>( B: &Builder<'ll>, - Val: &'ll Value, + Val: Value<'ll>, DestTy: Type<'ll>, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMBuildBitCast<'ll>( B: &Builder<'ll>, - Val: &'ll Value, + Val: Value<'ll>, DestTy: Type<'ll>, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMBuildPointerCast<'ll>( B: &Builder<'ll>, - Val: &'ll Value, + Val: Value<'ll>, DestTy: Type<'ll>, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMBuildIntCast2<'ll>( B: &Builder<'ll>, - Val: &'ll Value, + Val: Value<'ll>, DestTy: Type<'ll>, IsSigned: Bool, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; // Comparisons - pub(crate) fn LLVMBuildICmp<'a>( - B: &Builder<'a>, + pub(crate) fn LLVMBuildICmp<'ll>( + B: &Builder<'ll>, Op: c_uint, - LHS: &'a Value, - RHS: &'a Value, + LHS: Value<'ll>, + RHS: Value<'ll>, Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildFCmp<'a>( - B: &Builder<'a>, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildFCmp<'ll>( + B: &Builder<'ll>, Op: c_uint, - LHS: &'a Value, - RHS: &'a Value, + LHS: Value<'ll>, + RHS: Value<'ll>, Name: *const c_char, - ) -> &'a Value; + ) -> Value<'ll>; // Miscellaneous instructions pub(crate) fn LLVMBuildPhi<'ll>( B: &Builder<'ll>, Ty: Type<'ll>, Name: *const c_char, - ) -> &'ll Value; - pub(crate) fn LLVMBuildSelect<'a>( - B: &Builder<'a>, - If: &'a Value, - Then: &'a Value, - Else: &'a Value, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildSelect<'ll>( + B: &Builder<'ll>, + If: Value<'ll>, + Then: Value<'ll>, + Else: Value<'ll>, Name: *const c_char, - ) -> &'a Value; + ) -> Value<'ll>; pub(crate) fn LLVMBuildVAArg<'ll>( B: &Builder<'ll>, - list: &'ll Value, + list: Value<'ll>, Ty: Type<'ll>, Name: *const c_char, - ) -> &'ll Value; - pub(crate) fn LLVMBuildExtractElement<'a>( - B: &Builder<'a>, - VecVal: &'a Value, - Index: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildInsertElement<'a>( - B: &Builder<'a>, - VecVal: &'a Value, - EltVal: &'a Value, - Index: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildShuffleVector<'a>( - B: &Builder<'a>, - V1: &'a Value, - V2: &'a Value, - Mask: &'a Value, - Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildExtractValue<'a>( - B: &Builder<'a>, - AggVal: &'a Value, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildExtractElement<'ll>( + B: &Builder<'ll>, + VecVal: Value<'ll>, + Index: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildInsertElement<'ll>( + B: &Builder<'ll>, + VecVal: Value<'ll>, + EltVal: Value<'ll>, + Index: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildShuffleVector<'ll>( + B: &Builder<'ll>, + V1: Value<'ll>, + V2: Value<'ll>, + Mask: Value<'ll>, + Name: *const c_char, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildExtractValue<'ll>( + B: &Builder<'ll>, + AggVal: Value<'ll>, Index: c_uint, Name: *const c_char, - ) -> &'a Value; - pub(crate) fn LLVMBuildInsertValue<'a>( - B: &Builder<'a>, - AggVal: &'a Value, - EltVal: &'a Value, + ) -> Value<'ll>; + pub(crate) fn LLVMBuildInsertValue<'ll>( + B: &Builder<'ll>, + AggVal: Value<'ll>, + EltVal: Value<'ll>, Index: c_uint, Name: *const c_char, - ) -> &'a Value; + ) -> Value<'ll>; // Atomic Operations - pub(crate) fn LLVMBuildAtomicCmpXchg<'a>( - B: &Builder<'a>, - LHS: &'a Value, - CMP: &'a Value, - RHS: &'a Value, + pub(crate) fn LLVMBuildAtomicCmpXchg<'ll>( + B: &Builder<'ll>, + LHS: Value<'ll>, + CMP: Value<'ll>, + RHS: Value<'ll>, Order: AtomicOrdering, FailureOrder: AtomicOrdering, SingleThreaded: Bool, - ) -> &'a Value; + ) -> Value<'ll>; - pub(crate) fn LLVMSetWeak(CmpXchgInst: &Value, IsWeak: Bool); + pub(crate) fn LLVMSetWeak<'ll>(CmpXchgInst: Value<'ll>, IsWeak: Bool); - pub(crate) fn LLVMBuildAtomicRMW<'a>( - B: &Builder<'a>, + pub(crate) fn LLVMBuildAtomicRMW<'ll>( + B: &Builder<'ll>, Op: AtomicRmwBinOp, - LHS: &'a Value, - RHS: &'a Value, + LHS: Value<'ll>, + RHS: Value<'ll>, Order: AtomicOrdering, SingleThreaded: Bool, - ) -> &'a Value; + ) -> Value<'ll>; - pub(crate) fn LLVMBuildFence<'a>( - B: &Builder<'a>, + pub(crate) fn LLVMBuildFence<'ll>( + B: &Builder<'ll>, Order: AtomicOrdering, SingleThreaded: Bool, Name: *const c_char, - ) -> &'a Value; + ) -> Value<'ll>; /// Writes a module to the specified path. Returns 0 on success. pub(crate) fn LLVMWriteBitcodeToFile<'ll>(M: Module<'ll>, Path: *const c_char) -> c_int; @@ -1701,58 +1724,58 @@ unsafe extern "C" { pub(crate) fn LLVMCountStructElementTypes<'ll>(StructTy: Type<'ll>) -> c_uint; pub(crate) fn LLVMGetStructElementTypes<'ll>(StructTy: Type<'ll>, Dest: *mut Type<'ll>); - pub(crate) safe fn LLVMMetadataAsValue<'ll>(C: Context<'ll>, MD: &'ll Metadata) -> &'ll Value; + pub(crate) safe fn LLVMMetadataAsValue<'ll>(C: Context<'ll>, MD: &'ll Metadata) -> Value<'ll>; - pub(crate) safe fn LLVMSetUnnamedAddress(Global: &Value, UnnamedAddr: UnnamedAddr); + pub(crate) safe fn LLVMSetUnnamedAddress<'ll>(Global: Value<'ll>, UnnamedAddr: UnnamedAddr); - pub(crate) fn LLVMIsAConstantInt(value_ref: &Value) -> Option<&ConstantInt>; + pub(crate) fn LLVMIsAConstantInt<'ll>(value_ref: Value<'ll>) -> Option<&'ll ConstantInt>; pub(crate) fn LLVMGetOrInsertComdat<'ll>(M: Module<'ll>, Name: *const c_char) -> &'ll Comdat; - pub(crate) fn LLVMSetComdat(V: &Value, C: &Comdat); + pub(crate) fn LLVMSetComdat<'ll>(V: Value<'ll>, C: &Comdat); - pub(crate) fn LLVMCreateOperandBundle( + pub(crate) fn LLVMCreateOperandBundle<'ll>( Tag: *const c_uchar, // See "PTR_LEN_STR". TagLen: size_t, - Args: *const &'_ Value, + Args: *const Value<'ll>, NumArgs: c_uint, - ) -> *mut OperandBundle<'_>; + ) -> *mut OperandBundle<'ll>; pub(crate) fn LLVMDisposeOperandBundle(Bundle: ptr::NonNull>); pub(crate) fn LLVMBuildCallWithOperandBundles<'ll>( B: &Builder<'ll>, Ty: Type<'ll>, - Fn: &'ll Value, - Args: *const &'ll Value, + Fn: Value<'ll>, + Args: *const Value<'ll>, NumArgs: c_uint, Bundles: *const &OperandBundle<'ll>, NumBundles: c_uint, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMBuildInvokeWithOperandBundles<'ll>( B: &Builder<'ll>, Ty: Type<'ll>, - Fn: &'ll Value, - Args: *const &'ll Value, + Fn: Value<'ll>, + Args: *const Value<'ll>, NumArgs: c_uint, Then: &'ll BasicBlock, Catch: &'ll BasicBlock, Bundles: *const &OperandBundle<'ll>, NumBundles: c_uint, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMBuildCallBr<'ll>( B: &Builder<'ll>, Ty: Type<'ll>, - Fn: &'ll Value, + Fn: Value<'ll>, DefaultDest: &'ll BasicBlock, IndirectDests: *const &'ll BasicBlock, NumIndirectDests: c_uint, - Args: *const &'ll Value, + Args: *const Value<'ll>, NumArgs: c_uint, Bundles: *const &OperandBundle<'ll>, NumBundles: c_uint, Name: *const c_char, - ) -> &'ll Value; + ) -> Value<'ll>; } // FFI bindings for `DIBuilder` functions in the LLVM-C API. @@ -1902,7 +1925,7 @@ unsafe extern "C" { LineNumber: c_uint, Type: &'ll Metadata, Flags: DIFlags, - ConstantVal: Option<&'ll Value>, + ConstantVal: Option>, AlignInBits: u32, ) -> &'ll Metadata; @@ -1961,7 +1984,7 @@ unsafe extern "C" { pub(crate) fn LLVMDIBuilderInsertDeclareRecordAtEnd<'ll>( Builder: &DIBuilder<'ll>, - Storage: &'ll Value, + Storage: Value<'ll>, VarInfo: &'ll Metadata, Expr: &'ll Metadata, DebugLoc: &'ll Metadata, @@ -1970,7 +1993,7 @@ unsafe extern "C" { pub(crate) fn LLVMDIBuilderInsertDbgValueRecordAtEnd<'ll>( Builder: &DIBuilder<'ll>, - Val: &'ll Value, + Val: Value<'ll>, VarInfo: &'ll Metadata, Expr: &'ll Metadata, DebugLoc: &'ll Metadata, @@ -2010,8 +2033,8 @@ unsafe extern "C" { pub(crate) fn LLVMRustDisableSystemDialogsOnCrash(); // Operations on all values - pub(crate) fn LLVMRustIsNonGVFunctionPointerTy(Val: &Value) -> bool; - pub(crate) fn LLVMRustStripPointerCasts<'a>(Val: &'a Value) -> &'a Value; + pub(crate) fn LLVMRustIsNonGVFunctionPointerTy<'ll>(Val: Value<'ll>) -> bool; + pub(crate) fn LLVMRustStripPointerCasts<'ll>(Val: Value<'ll>) -> Value<'ll>; // Operations on scalar constants pub(crate) fn LLVMRustConstIntGetZExtValue(ConstantVal: &ConstantInt, Value: &mut u64) -> bool; @@ -2023,7 +2046,7 @@ unsafe extern "C" { ) -> bool; // Operations on global variables, functions, and aliases (globals) - pub(crate) fn LLVMRustSetDSOLocal(Global: &Value, is_dso_local: bool); + pub(crate) fn LLVMRustSetDSOLocal<'ll>(Global: Value<'ll>, is_dso_local: bool); // Operations on global variables pub(crate) fn LLVMRustGetOrInsertGlobal<'ll>( @@ -2031,19 +2054,19 @@ unsafe extern "C" { Name: *const c_uchar, // See "PTR_LEN_STR". NameLen: size_t, T: Type<'ll>, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMRustGetOrInsertGlobalInAddrspace<'ll>( M: Module<'ll>, Name: *const c_uchar, // See "PTR_LEN_STR". NameLen: size_t, T: Type<'ll>, AddressSpace: c_uint, - ) -> &'ll Value; + ) -> Value<'ll>; pub(crate) fn LLVMRustGetNamedValue<'ll>( M: Module<'ll>, Name: *const c_uchar, // See "PTR_LEN_STR". NameLen: size_t, - ) -> Option<&'ll Value>; + ) -> Option>; // Operations on attributes pub(crate) fn LLVMRustCreateAttrNoValue<'ll>( @@ -2096,55 +2119,55 @@ unsafe extern "C" { ) -> &'ll Attribute; // Operations on functions - pub(crate) fn LLVMRustAddFunctionAttributes<'a>( - Fn: &'a Value, + pub(crate) fn LLVMRustAddFunctionAttributes<'ll>( + Fn: Value<'ll>, index: c_uint, - Attrs: *const &'a Attribute, + Attrs: *const &'ll Attribute, AttrsLen: size_t, ); // Operations on call sites - pub(crate) fn LLVMRustAddCallSiteAttributes<'a>( - Instr: &'a Value, + pub(crate) fn LLVMRustAddCallSiteAttributes<'ll>( + Instr: Value<'ll>, index: c_uint, - Attrs: *const &'a Attribute, + Attrs: *const &'ll Attribute, AttrsLen: size_t, ); - pub(crate) fn LLVMRustSetFastMath(Instr: &Value); - pub(crate) fn LLVMRustSetAlgebraicMath(Instr: &Value); - pub(crate) fn LLVMRustSetAllowReassoc(Instr: &Value); - pub(crate) fn LLVMRustSetNoSignedZeros(Instr: &Value); + pub(crate) fn LLVMRustSetFastMath<'ll>(Instr: Value<'ll>); + pub(crate) fn LLVMRustSetAlgebraicMath<'ll>(Instr: Value<'ll>); + pub(crate) fn LLVMRustSetAllowReassoc<'ll>(Instr: Value<'ll>); + pub(crate) fn LLVMRustSetNoSignedZeros<'ll>(Instr: Value<'ll>); // Miscellaneous instructions - pub(crate) fn LLVMRustBuildMemCpy<'a>( - B: &Builder<'a>, - Dst: &'a Value, + pub(crate) fn LLVMRustBuildMemCpy<'ll>( + B: &Builder<'ll>, + Dst: Value<'ll>, DstAlign: c_uint, - Src: &'a Value, + Src: Value<'ll>, SrcAlign: c_uint, - Size: &'a Value, + Size: Value<'ll>, IsVolatile: bool, - ) -> &'a Value; - pub(crate) fn LLVMRustBuildMemMove<'a>( - B: &Builder<'a>, - Dst: &'a Value, + ) -> Value<'ll>; + pub(crate) fn LLVMRustBuildMemMove<'ll>( + B: &Builder<'ll>, + Dst: Value<'ll>, DstAlign: c_uint, - Src: &'a Value, + Src: Value<'ll>, SrcAlign: c_uint, - Size: &'a Value, + Size: Value<'ll>, IsVolatile: bool, - ) -> &'a Value; - pub(crate) fn LLVMRustBuildMemSet<'a>( - B: &Builder<'a>, - Dst: &'a Value, + ) -> Value<'ll>; + pub(crate) fn LLVMRustBuildMemSet<'ll>( + B: &Builder<'ll>, + Dst: Value<'ll>, DstAlign: c_uint, - Val: &'a Value, - Size: &'a Value, + Val: Value<'ll>, + Size: Value<'ll>, IsVolatile: bool, - ) -> &'a Value; + ) -> Value<'ll>; - pub(crate) fn LLVMRustBuildVScale<'ll>(B: &Builder<'ll>, Ty: Type<'ll>) -> &'ll Value; + pub(crate) fn LLVMRustBuildVScale<'ll>(B: &Builder<'ll>, Ty: Type<'ll>) -> Value<'ll>; pub(crate) fn LLVMRustTimeTraceProfilerInitialize(); @@ -2206,11 +2229,11 @@ unsafe extern "C" { BufferOut: &RustString, ); - pub(crate) fn LLVMRustCoverageCreatePGOFuncNameVar( - F: &Value, + pub(crate) fn LLVMRustCoverageCreatePGOFuncNameVar<'ll>( + F: Value<'ll>, FuncName: *const c_uchar, // See "PTR_LEN_STR". FuncNameLen: size_t, - ) -> &Value; + ) -> Value<'ll>; pub(crate) fn LLVMRustCoverageHashBytes( Bytes: *const c_uchar, // See "PTR_LEN_STR". NumBytes: size_t, @@ -2295,23 +2318,23 @@ unsafe extern "C" { /// We can't use LLVM-C's `LLVMDIBuilderCreateFunction` because it only /// supports a subset of `DISubprogram::DISPFlags`. - pub(crate) fn LLVMRustDIBuilderCreateFunction<'a>( - Builder: &DIBuilder<'a>, - Scope: &'a DIDescriptor, + pub(crate) fn LLVMRustDIBuilderCreateFunction<'ll>( + Builder: &DIBuilder<'ll>, + Scope: &'ll DIDescriptor, Name: *const c_uchar, // See "PTR_LEN_STR". NameLen: size_t, LinkageName: *const c_uchar, // See "PTR_LEN_STR". LinkageNameLen: size_t, - File: &'a DIFile, + File: &'ll DIFile, LineNo: c_uint, - Ty: &'a DIType, + Ty: &'ll DIType, ScopeLine: c_uint, Flags: DIFlags, SPFlags: DISPFlags, - MaybeFn: Option<&'a Value>, - TParam: &'a DIArray, - Decl: Option<&'a DIDescriptor>, - ) -> &'a DISubprogram; + MaybeFn: Option>, + TParam: &'ll DIArray, + Decl: Option<&'ll DIDescriptor>, + ) -> &'ll DISubprogram; /// As of LLVM 22 there is no corresponding LLVM-C function. pub(crate) fn LLVMRustDIBuilderCreateMethod<'a>( @@ -2330,20 +2353,20 @@ unsafe extern "C" { ) -> &'a DISubprogram; /// As of LLVM 22 there is no corresponding LLVM-C function. - pub(crate) fn LLVMRustDIBuilderCreateVariantMemberType<'a>( - Builder: &DIBuilder<'a>, - Scope: &'a DIScope, + pub(crate) fn LLVMRustDIBuilderCreateVariantMemberType<'ll>( + Builder: &DIBuilder<'ll>, + Scope: &'ll DIScope, Name: *const c_uchar, // See "PTR_LEN_STR". NameLen: size_t, - File: &'a DIFile, + File: &'ll DIFile, LineNumber: c_uint, SizeInBits: u64, AlignInBits: u32, OffsetInBits: u64, - Discriminant: Option<&'a Value>, + Discriminant: Option>, Flags: DIFlags, - Ty: &'a DIType, - ) -> &'a DIType; + Ty: &'ll DIType, + ) -> &'ll DIType; /// As of LLVM 22 there is no corresponding LLVM-C function. pub(crate) fn LLVMRustDIBuilderCreateEnumerationType<'a>( @@ -2423,7 +2446,7 @@ unsafe extern "C" { ) -> Option<&'a DILocation>; pub(crate) fn LLVMRustWriteTypeToString<'ll>(Type: Type<'ll>, s: &RustString); - pub(crate) fn LLVMRustWriteValueToString(value_ref: &Value, s: &RustString); + pub(crate) fn LLVMRustWriteValueToString<'ll>(value_ref: Value<'ll>, s: &RustString); pub(crate) fn LLVMRustTargetHasMnemonic(T: &TargetMachine, s: *const c_char) -> bool; @@ -2543,10 +2566,10 @@ unsafe extern "C" { pub(crate) fn LLVMRustWriteTwineToString(T: &Twine, s: &RustString); - pub(crate) fn LLVMRustUnpackOptimizationDiagnostic<'a>( - DI: &'a DiagnosticInfo, + pub(crate) fn LLVMRustUnpackOptimizationDiagnostic<'ll>( + DI: &'ll DiagnosticInfo, pass_name_out: &RustString, - function_out: &mut Option<&'a Value>, + function_out: &mut Option>, loc_line_out: &mut c_uint, loc_column_out: &mut c_uint, loc_filename_out: &RustString, @@ -2579,7 +2602,7 @@ unsafe extern "C" { pub(crate) fn LLVMRustSetDataLayoutFromTargetMachine<'ll>(M: Module<'ll>, TM: &TargetMachine); - pub(crate) fn LLVMRustPositionBuilderPastAllocas<'a>(B: &Builder<'a>, Fn: &'a Value); + pub(crate) fn LLVMRustPositionBuilderPastAllocas<'ll>(B: &Builder<'ll>, Fn: Value<'ll>); pub(crate) fn LLVMRustPositionBuilderAtStart<'a>(B: &Builder<'a>, BB: &'a BasicBlock); pub(crate) fn LLVMRustSetModulePICLevel<'ll>(M: Module<'ll>); @@ -2665,9 +2688,9 @@ unsafe extern "C" { pgo_available: bool, ); - pub(crate) fn LLVMRustGetMangledName(V: &Value, out: &RustString); + pub(crate) fn LLVMRustGetMangledName<'ll>(V: Value<'ll>, out: &RustString); - pub(crate) fn LLVMRustGetElementTypeArgIndex(CallSite: &Value) -> i32; + pub(crate) fn LLVMRustGetElementTypeArgIndex<'ll>(CallSite: Value<'ll>) -> i32; pub(crate) safe fn LLVMRustLLVMHasZlibCompression() -> bool; pub(crate) safe fn LLVMRustLLVMHasZstdCompression() -> bool; @@ -2686,14 +2709,14 @@ unsafe extern "C" { pub(crate) fn LLVMRustIsAnyArm64Coff(buf_ptr: *const u8, buf_len: usize) -> bool; - pub(crate) fn LLVMRustSetNoSanitizeAddress(Global: &Value); - pub(crate) fn LLVMRustSetNoSanitizeHWAddress(Global: &Value); + pub(crate) fn LLVMRustSetNoSanitizeAddress<'ll>(Global: Value<'ll>); + pub(crate) fn LLVMRustSetNoSanitizeHWAddress<'ll>(Global: Value<'ll>); - pub(crate) fn LLVMRustConstPtrAuth( - ptr: *const Value, + pub(crate) fn LLVMRustConstPtrAuth<'ll>( + ptr: Value<'ll>, key: u32, disc: u64, - addr_diversity: *const Value, - deactivation_symbol: *const Value, - ) -> *const Value; + addr_diversity: Option>, + deactivation_symbol: Option>, + ) -> Value<'ll>; } diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi/branded.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi/branded.rs index 4086c41459a4c..3cdcc78fa760d 100644 --- a/compiler/rustc_codegen_llvm/src/llvm/ffi/branded.rs +++ b/compiler/rustc_codegen_llvm/src/llvm/ffi/branded.rs @@ -75,3 +75,17 @@ unsafe extern "C" { /// Pointee type of the raw pointer wrapped by [`Type`]. type TypeRaw; } + +/// Corresponds to `LLVMValueRef`. +#[derive(Clone, Copy, PartialEq, Eq, Hash)] +#[repr(transparent)] +#[rustc_pass_by_value] +pub(crate) struct Value<'ll> { + llval_raw: ptr::NonNull, + _invariant_ll: PhantomInvariantLifetime<'ll>, +} + +unsafe extern "C" { + /// Pointee type of the raw pointer wrapped by [`Value`]. + type ValueRaw; +} diff --git a/compiler/rustc_codegen_llvm/src/llvm/mod.rs b/compiler/rustc_codegen_llvm/src/llvm/mod.rs index 168cc40ee579c..c662ad09f49d7 100644 --- a/compiler/rustc_codegen_llvm/src/llvm/mod.rs +++ b/compiler/rustc_codegen_llvm/src/llvm/mod.rs @@ -34,7 +34,7 @@ impl LLVMRustResult { } pub(crate) fn AddFunctionAttributes<'ll>( - llfn: &'ll Value, + llfn: Value<'ll>, idx: AttributePlace, attrs: &[&'ll Attribute], ) { @@ -43,16 +43,16 @@ pub(crate) fn AddFunctionAttributes<'ll>( } } -pub(crate) fn HasStringAttribute<'ll>(llfn: &'ll Value, name: &str) -> bool { +pub(crate) fn HasStringAttribute<'ll>(llfn: Value<'ll>, name: &str) -> bool { unsafe { LLVMRustHasFnAttribute(llfn, name.as_ptr(), name.len()) } } -pub(crate) fn RemoveStringAttrFromFn<'ll>(llfn: &'ll Value, name: &str) { +pub(crate) fn RemoveStringAttrFromFn<'ll>(llfn: Value<'ll>, name: &str) { unsafe { LLVMRustRemoveFnAttribute(llfn, name.as_ptr(), name.len()) } } pub(crate) fn AddCallSiteAttributes<'ll>( - callsite: &'ll Value, + callsite: Value<'ll>, idx: AttributePlace, attrs: &[&'ll Attribute], ) { @@ -194,12 +194,12 @@ impl AttributePlace { } } -pub(crate) fn SetInstructionCallConv(instr: &Value, cc: CallConv) { +pub(crate) fn SetInstructionCallConv<'ll>(instr: Value<'ll>, cc: CallConv) { unsafe { LLVMSetInstructionCallConv(instr, cc as c_uint); } } -pub(crate) fn SetFunctionCallConv(fn_: &Value, cc: CallConv) { +pub(crate) fn SetFunctionCallConv<'ll>(fn_: Value<'ll>, cc: CallConv) { unsafe { LLVMSetFunctionCallConv(fn_, cc as c_uint); } @@ -211,18 +211,18 @@ pub(crate) fn SetFunctionCallConv(fn_: &Value, cc: CallConv) { // value's name as the comdat value to make sure that it is in a 1-to-1 relationship to the // function. // For more details on COMDAT sections see e.g., https://www.airs.com/blog/archives/52 -pub(crate) fn SetUniqueComdat<'ll>(llmod: Module<'ll>, val: &'ll Value) { +pub(crate) fn SetUniqueComdat<'ll>(llmod: Module<'ll>, val: Value<'ll>) { let name_buf = get_value_name(val); let name = CString::from_vec_with_nul(name_buf).or_else(|buf| CString::new(buf.into_bytes())).unwrap(); set_comdat(llmod, val, &name); } -pub(crate) fn set_unnamed_address(global: &Value, unnamed: UnnamedAddr) { +pub(crate) fn set_unnamed_address<'ll>(global: Value<'ll>, unnamed: UnnamedAddr) { LLVMSetUnnamedAddress(global, unnamed); } -pub(crate) fn set_thread_local_mode(global: &Value, mode: ThreadLocalMode) { +pub(crate) fn set_thread_local_mode<'ll>(global: Value<'ll>, mode: ThreadLocalMode) { unsafe { LLVMSetThreadLocalMode(global, mode); } @@ -242,17 +242,17 @@ impl MemoryEffects { } } -pub(crate) fn set_section(llglobal: &Value, section_name: &CStr) { +pub(crate) fn set_section<'ll>(llglobal: Value<'ll>, section_name: &CStr) { unsafe { LLVMSetSection(llglobal, section_name.as_ptr()); } } -pub(crate) fn add_global<'ll>(llmod: Module<'ll>, ty: Type<'ll>, name_cstr: &CStr) -> &'ll Value { +pub(crate) fn add_global<'ll>(llmod: Module<'ll>, ty: Type<'ll>, name_cstr: &CStr) -> Value<'ll> { unsafe { LLVMAddGlobal(llmod, ty, name_cstr.as_ptr()) } } -pub(crate) fn set_initializer(llglobal: &Value, constant_val: &Value) { +pub(crate) fn set_initializer<'ll>(llglobal: Value<'ll>, constant_val: Value<'ll>) { unsafe { assert_eq!( crate::llvm::LLVMGlobalGetValueType(llglobal), @@ -264,41 +264,41 @@ pub(crate) fn set_initializer(llglobal: &Value, constant_val: &Value) { } } -pub(crate) fn set_global_constant(llglobal: &Value, is_constant: bool) { +pub(crate) fn set_global_constant<'ll>(llglobal: Value<'ll>, is_constant: bool) { LLVMSetGlobalConstant(llglobal, is_constant.to_llvm_bool()); } -pub(crate) fn get_linkage(llglobal: &Value) -> Linkage { +pub(crate) fn get_linkage<'ll>(llglobal: Value<'ll>) -> Linkage { unsafe { LLVMGetLinkage(llglobal) }.to_rust() } -pub(crate) fn set_linkage(llglobal: &Value, linkage: Linkage) { +pub(crate) fn set_linkage<'ll>(llglobal: Value<'ll>, linkage: Linkage) { unsafe { LLVMSetLinkage(llglobal, linkage); } } -pub(crate) fn is_declaration(llglobal: &Value) -> bool { +pub(crate) fn is_declaration<'ll>(llglobal: Value<'ll>) -> bool { unsafe { LLVMIsDeclaration(llglobal) }.is_true() } -pub(crate) fn get_visibility(llglobal: &Value) -> Visibility { +pub(crate) fn get_visibility<'ll>(llglobal: Value<'ll>) -> Visibility { unsafe { LLVMGetVisibility(llglobal) }.to_rust() } -pub(crate) fn set_visibility(llglobal: &Value, visibility: Visibility) { +pub(crate) fn set_visibility<'ll>(llglobal: Value<'ll>, visibility: Visibility) { unsafe { LLVMSetVisibility(llglobal, visibility); } } -pub(crate) fn set_alignment(llglobal: &Value, align: Align) { +pub(crate) fn set_alignment<'ll>(llglobal: Value<'ll>, align: Align) { unsafe { ffi::LLVMSetAlignment(llglobal, align.bytes() as c_uint); } } -pub(crate) fn set_externally_initialized(llglobal: &Value, is_ext_init: bool) { +pub(crate) fn set_externally_initialized<'ll>(llglobal: Value<'ll>, is_ext_init: bool) { LLVMSetExternallyInitialized(llglobal, is_ext_init.to_llvm_bool()); } @@ -306,19 +306,19 @@ pub(crate) fn set_externally_initialized(llglobal: &Value, is_ext_init: bool) { /// /// Inserts the comdat into `llmod` if it does not exist. /// It is an error to call this if the target does not support comdat. -pub(crate) fn set_comdat<'ll>(llmod: Module<'ll>, llglobal: &'ll Value, name: &CStr) { +pub(crate) fn set_comdat<'ll>(llmod: Module<'ll>, llglobal: Value<'ll>, name: &CStr) { unsafe { let comdat = LLVMGetOrInsertComdat(llmod, name.as_ptr()); LLVMSetComdat(llglobal, comdat); } } -pub(crate) fn count_params(llfn: &Value) -> c_uint { +pub(crate) fn count_params<'ll>(llfn: Value<'ll>) -> c_uint { LLVMCountParams(llfn) } /// Safe wrapper around `LLVMGetParam`, because segfaults are no fun. -pub(crate) fn get_param(llfn: &Value, index: c_uint) -> &Value { +pub(crate) fn get_param<'ll>(llfn: Value<'ll>, index: c_uint) -> Value<'ll> { unsafe { assert!( index < LLVMCountParams(llfn), @@ -333,7 +333,7 @@ pub(crate) fn get_param(llfn: &Value, index: c_uint) -> &Value { /// Safe wrapper for `LLVMGetValueName2` /// Needs to allocate the value, because `set_value_name` will invalidate /// the pointer. -pub(crate) fn get_value_name(value: &Value) -> Vec { +pub(crate) fn get_value_name<'ll>(value: Value<'ll>) -> Vec { unsafe { let mut len = 0; let data = LLVMGetValueName2(value, &mut len); @@ -364,7 +364,7 @@ impl Intrinsic { self, llmod: Module<'ll>, type_params: &[Type<'ll>], - ) -> &'ll Value { + ) -> Value<'ll> { unsafe { LLVMGetIntrinsicDeclaration(llmod, self.id, type_params.as_ptr(), type_params.len()) } @@ -372,7 +372,7 @@ impl Intrinsic { } /// Safe wrapper for `LLVMSetValueName2` from a byte slice -pub(crate) fn set_value_name(value: &Value, name: &[u8]) { +pub(crate) fn set_value_name<'ll>(value: Value<'ll>, name: &[u8]) { assert!(!name.contains(&0)); unsafe { LLVMSetValueName2(value, name.as_ptr(), name.len()) }; } @@ -407,12 +407,12 @@ pub(crate) fn last_error() -> Option { /// Owning pointer to an [`OperandBundle`] that will dispose of the bundle /// when dropped. -pub(crate) struct OperandBundleBox<'a> { - raw: ptr::NonNull>, +pub(crate) struct OperandBundleBox<'ll> { + raw: ptr::NonNull>, } -impl<'a> OperandBundleBox<'a> { - pub(crate) fn new(name: &str, vals: &[&'a Value]) -> Self { +impl<'ll> OperandBundleBox<'ll> { + pub(crate) fn new(name: &str, vals: &[Value<'ll>]) -> Self { let raw = unsafe { LLVMCreateOperandBundle(name.as_ptr(), name.len(), vals.as_ptr(), vals.len() as c_uint) }; @@ -423,7 +423,7 @@ impl<'a> OperandBundleBox<'a> { /// /// This can't be a `Deref` implementation because `OperandBundle` transitively /// contains an extern type, which is incompatible with `Deref::Target: ?Sized`. - pub(crate) fn as_ref(&self) -> &OperandBundle<'a> { + pub(crate) fn as_ref(&self) -> &OperandBundle<'ll> { // SAFETY: The returned reference is opaque and can only used for FFI. // It is valid for as long as `&self` is. unsafe { self.raw.as_ref() } @@ -467,13 +467,13 @@ pub(crate) fn add_module_flag_str<'ll>( } } -pub(crate) fn set_dllimport_storage_class<'ll>(v: &'ll Value) { +pub(crate) fn set_dllimport_storage_class<'ll>(v: Value<'ll>) { unsafe { LLVMSetDLLStorageClass(v, DLLStorageClass::DllImport); } } -pub(crate) fn set_dso_local<'ll>(v: &'ll Value) { +pub(crate) fn set_dso_local<'ll>(v: Value<'ll>) { unsafe { LLVMRustSetDSOLocal(v, true); } @@ -505,24 +505,18 @@ pub(crate) fn add_alias<'ll>( module: Module<'ll>, ty: Type<'ll>, address_space: AddressSpace, - aliasee: &Value, + aliasee: Value<'ll>, name: &CStr, -) -> &'ll Value { +) -> Value<'ll> { unsafe { LLVMAddAlias2(module, ty, address_space.0, aliasee, name.as_ptr()) } } /// Safe wrapper for `LLVMRustConstPtrAuth`. pub(crate) fn const_ptr_auth<'ll>( - ptr: &'ll Value, + ptr: Value<'ll>, key: u32, disc: u64, - addr_diversity: Option<&'ll Value>, -) -> &'ll Value { - unsafe { - let addr_div_ptr = addr_diversity.map_or(std::ptr::null(), |v| v as *const Value); - let deactivation_symbol = std::ptr::null(); - let result = - LLVMRustConstPtrAuth(ptr as *const Value, key, disc, addr_div_ptr, deactivation_symbol); - &*result - } + addr_diversity: Option>, +) -> Value<'ll> { + unsafe { LLVMRustConstPtrAuth(ptr, key, disc, addr_diversity, None) } } diff --git a/compiler/rustc_codegen_llvm/src/llvm/offload_ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/offload_ffi.rs index 4f2369aef0d53..d66554491b6c3 100644 --- a/compiler/rustc_codegen_llvm/src/llvm/offload_ffi.rs +++ b/compiler/rustc_codegen_llvm/src/llvm/offload_ffi.rs @@ -4,7 +4,8 @@ use std::sync::OnceLock; use super::ffi::{Module, Value}; -type LLVMRustOffloadMapperFn = unsafe extern "C" fn(&Value, &Value, *const &Value); +type LLVMRustOffloadMapperFn = + for<'ll> unsafe extern "C" fn(Value<'ll>, Value<'ll>, *const Value<'ll>); type LLVMRustOffloadWrapImagesFn = for<'ll> unsafe extern "C" fn(Module<'ll>, *const c_char) -> bool; @@ -50,7 +51,12 @@ impl RustOffloadWrapper { .expect("RustOffloadWrapper not initialized. Call get_or_init with sysroot first.") } - pub(crate) unsafe fn llvm_rust_offload_wrapper(&self, v1: &Value, v2: &Value, vs: &[&Value]) { + pub(crate) unsafe fn llvm_rust_offload_wrapper<'ll>( + &self, + v1: Value<'ll>, + v2: Value<'ll>, + vs: &[Value<'ll>], + ) { unsafe { (self.LLVMRustOffloadMapper)(v1, v2, vs.as_ptr()) } } diff --git a/compiler/rustc_codegen_llvm/src/mono_item.rs b/compiler/rustc_codegen_llvm/src/mono_item.rs index 82bd5584211c0..cf674b1fd2f71 100644 --- a/compiler/rustc_codegen_llvm/src/mono_item.rs +++ b/compiler/rustc_codegen_llvm/src/mono_item.rs @@ -82,7 +82,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> { linkage: Linkage, visibility: Visibility, symbol_name: &str, - ) -> &'ll llvm::Value { + ) -> llvm::Value<'ll> { let fn_abi: &FnAbi<'tcx, Ty<'tcx>> = self.fn_abi_of_instance(instance, ty::List::empty()); let lldecl = self.declare_fn(symbol_name, fn_abi, Some(instance)); llvm::set_linkage(lldecl, base::linkage_to_llvm(linkage)); @@ -132,7 +132,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> { /// So, this function is for static aliases. See [`add_function_aliases`](Self::add_function_aliases) for the alternative. fn add_static_aliases( &self, - aliasee: &'ll llvm::Value, + aliasee: llvm::Value<'ll>, aliases: &[(DefId, Linkage, Visibility)], ) { let ty = self.get_type_of_global(aliasee); @@ -166,7 +166,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> { fn add_function_aliases( &self, aliasee_instance: Instance<'tcx>, - aliasee: &'ll llvm::Value, + aliasee: llvm::Value<'ll>, attrs: &Cow<'_, CodegenFnAttrs>, aliases: &[(DefId, Linkage, Visibility)], ) { @@ -233,7 +233,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> { /// A definition or declaration can be assumed to be local to a group of /// libraries that form a single DSO or executable. /// Marks the local as DSO if so. - pub(crate) fn assume_dso_local(&self, llval: &llvm::Value, is_declaration: bool) -> bool { + pub(crate) fn assume_dso_local(&self, llval: llvm::Value<'ll>, is_declaration: bool) -> bool { let assume = self.should_assume_dso_local(llval, is_declaration); if assume { llvm::set_dso_local(llval); @@ -241,7 +241,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> { assume } - fn set_visibility(&self, lldecl: &llvm::Value, linkage: Linkage, visibility: Visibility) { + fn set_visibility(&self, lldecl: llvm::Value<'ll>, linkage: Linkage, visibility: Visibility) { // If we're compiling the compiler-builtins crate, i.e., the equivalent of // compiler-rt, then we want to implicitly compile everything with hidden // visibility as we're going to link this object all over the place but @@ -253,7 +253,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> { } } - fn should_assume_dso_local(&self, llval: &llvm::Value, is_declaration: bool) -> bool { + fn should_assume_dso_local(&self, llval: llvm::Value<'ll>, is_declaration: bool) -> bool { let linkage = llvm::get_linkage(llval); let visibility = llvm::get_visibility(llval); diff --git a/compiler/rustc_codegen_llvm/src/type_.rs b/compiler/rustc_codegen_llvm/src/type_.rs index 55c546538611b..d69559593e227 100644 --- a/compiler/rustc_codegen_llvm/src/type_.rs +++ b/compiler/rustc_codegen_llvm/src/type_.rs @@ -56,7 +56,7 @@ impl<'ll, CX: Borrow>> GenericCx<'ll, CX> { unsafe { llvm::LLVMScalableVectorType(ty, count as c_uint) } } - pub(crate) fn add_func(&self, name: &str, ty: Type<'ll>) -> &'ll Value { + pub(crate) fn add_func(&self, name: &str, ty: Type<'ll>) -> Value<'ll> { let name = SmallCStr::new(name); unsafe { llvm::LLVMAddFunction(self.llmod(), name.as_ptr(), ty) } } @@ -274,7 +274,7 @@ impl<'ll, CX: Borrow>> BaseTypeCodegenMethods for GenericCx<'ll, CX> { } } - fn val_ty(&self, v: &'ll Value) -> Type<'ll> { + fn val_ty(&self, v: Value<'ll>) -> Type<'ll> { common::val_ty(v) } } @@ -320,24 +320,24 @@ impl<'ll, 'tcx> LayoutTypeCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> { } impl<'ll, 'tcx> TypeMembershipCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> { - fn add_type_metadata(&self, function: &'ll Value, typeid: &[u8]) { + fn add_type_metadata(&self, function: Value<'ll>, typeid: &[u8]) { let typeid_metadata = self.create_metadata(typeid); let v = [llvm::LLVMValueAsMetadata(self.const_usize(0)), typeid_metadata]; self.global_add_metadata_node(function, llvm::MD_type, &v); } - fn set_type_metadata(&self, function: &'ll Value, typeid: &[u8]) { + fn set_type_metadata(&self, function: Value<'ll>, typeid: &[u8]) { let typeid_metadata = self.create_metadata(typeid); let v = [llvm::LLVMValueAsMetadata(self.const_usize(0)), typeid_metadata]; self.global_set_metadata_node(function, llvm::MD_type, &v); } - fn add_kcfi_type_metadata(&self, function: &'ll Value, kcfi_typeid: u32) { + fn add_kcfi_type_metadata(&self, function: Value<'ll>, kcfi_typeid: u32) { let kcfi_type_metadata = [llvm::LLVMValueAsMetadata(self.const_u32(kcfi_typeid))]; self.global_add_metadata_node(function, llvm::MD_kcfi_type, &kcfi_type_metadata); } - fn set_kcfi_type_metadata(&self, function: &'ll Value, kcfi_typeid: u32) { + fn set_kcfi_type_metadata(&self, function: Value<'ll>, kcfi_typeid: u32) { let kcfi_type_metadata = [llvm::LLVMValueAsMetadata(self.const_u32(kcfi_typeid))]; self.global_set_metadata_node(function, llvm::MD_kcfi_type, &kcfi_type_metadata); } diff --git a/compiler/rustc_codegen_llvm/src/typetree.rs b/compiler/rustc_codegen_llvm/src/typetree.rs index efda11f399ba4..48959a0ae6739 100644 --- a/compiler/rustc_codegen_llvm/src/typetree.rs +++ b/compiler/rustc_codegen_llvm/src/typetree.rs @@ -75,7 +75,7 @@ enum TTLocation { Callsite, } -pub(crate) fn add_tt<'tcx, 'll>(cx: &FullCx<'ll, 'tcx>, fn_def: &'ll Value, tt: FncTree) { +pub(crate) fn add_tt<'tcx, 'll>(cx: &FullCx<'ll, 'tcx>, fn_def: Value<'ll>, tt: FncTree) { // TypeTree processing uses functions from Enzyme. This feature is not strictly necessary, // but skipping this function increases the chance that Enzyme fails to compile some code. diff --git a/compiler/rustc_codegen_llvm/src/va_arg.rs b/compiler/rustc_codegen_llvm/src/va_arg.rs index 7c2c20c2671e4..e06cdaca0ae5a 100644 --- a/compiler/rustc_codegen_llvm/src/va_arg.rs +++ b/compiler/rustc_codegen_llvm/src/va_arg.rs @@ -17,18 +17,18 @@ use crate::type_of::LayoutLlvmExt; fn round_up_to_alignment<'ll>( bx: &mut Builder<'_, 'll, '_>, - mut value: &'ll Value, + mut value: Value<'ll>, align: Align, -) -> &'ll Value { +) -> Value<'ll> { value = bx.add(value, bx.cx().const_i32(align.bytes() as i32 - 1)); return bx.and(value, bx.cx().const_i32(-(align.bytes() as i32))); } fn round_pointer_up_to_alignment<'ll>( bx: &mut Builder<'_, 'll, '_>, - addr: &'ll Value, + addr: Value<'ll>, align: Align, -) -> &'ll Value { +) -> Value<'ll> { let ptr = bx.inbounds_ptradd(addr, bx.const_i32(align.bytes() as i32 - 1)); let pointer_width = bx.tcx().sess.target.pointer_width; let mask = align.bytes().wrapping_neg() & (u64::MAX >> (64 - pointer_width)); @@ -41,13 +41,13 @@ fn round_pointer_up_to_alignment<'ll>( fn emit_direct_ptr_va_arg<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - list: OperandRef<'tcx, &'ll Value>, + list: OperandRef<'tcx, Value<'ll>>, size: Size, align: Align, slot_size: Align, allow_higher_align: bool, force_right_adjust: bool, -) -> (&'ll Value, Align) { +) -> (Value<'ll>, Align) { let va_list_ty = bx.type_ptr(); let va_list_addr = list.immediate(); @@ -155,13 +155,13 @@ enum ForceRightAdjust { fn emit_ptr_va_arg<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - list: OperandRef<'tcx, &'ll Value>, + list: OperandRef<'tcx, Value<'ll>>, layout: TyAndLayout<'tcx>, pass_mode: PassMode, slot_size: SlotSize, allow_higher_align: AllowHigherAlign, force_right_adjust: ForceRightAdjust, -) -> &'ll Value { +) -> Value<'ll> { let indirect = matches!(pass_mode, PassMode::Indirect); let allow_higher_align = matches!(allow_higher_align, AllowHigherAlign::Yes); let force_right_adjust = matches!(force_right_adjust, ForceRightAdjust::Yes); @@ -195,9 +195,9 @@ fn emit_ptr_va_arg<'ll, 'tcx>( fn emit_aapcs_va_arg<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - list: OperandRef<'tcx, &'ll Value>, + list: OperandRef<'tcx, Value<'ll>>, layout: TyAndLayout<'tcx>, -) -> &'ll Value { +) -> Value<'ll> { let dl = bx.cx.data_layout(); // Implementation of the AAPCS64 calling convention for va_args see @@ -315,9 +315,9 @@ fn is_powerpc_softfloat_abi(target: &Target) -> bool { fn emit_powerpc_va_arg<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - list: OperandRef<'tcx, &'ll Value>, + list: OperandRef<'tcx, Value<'ll>>, layout: TyAndLayout<'tcx>, -) -> &'ll Value { +) -> Value<'ll> { let dl = bx.cx.data_layout(); // struct __va_list_tag { @@ -443,9 +443,9 @@ fn emit_powerpc_va_arg<'ll, 'tcx>( fn emit_s390x_va_arg<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - list: OperandRef<'tcx, &'ll Value>, + list: OperandRef<'tcx, Value<'ll>>, layout: TyAndLayout<'tcx>, -) -> &'ll Value { +) -> Value<'ll> { let dl = bx.cx.data_layout(); // Implementation of the s390x ELF ABI calling convention for va_args see @@ -551,9 +551,9 @@ fn emit_s390x_va_arg<'ll, 'tcx>( fn emit_x86_64_sysv64_va_arg<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - list: OperandRef<'tcx, &'ll Value>, + list: OperandRef<'tcx, Value<'ll>>, layout: TyAndLayout<'tcx>, -) -> &'ll Value { +) -> Value<'ll> { let dl = bx.cx.data_layout(); // Implementation of the systemv x86_64 ABI calling convention for va_args, see @@ -797,10 +797,10 @@ fn emit_x86_64_sysv64_va_arg<'ll, 'tcx>( /// Copy into a temporary if the type is more aligned than the register save area. fn copy_to_temporary_if_more_aligned<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - reg_addr: &'ll Value, + reg_addr: Value<'ll>, layout: TyAndLayout<'tcx>, src_align: Align, -) -> &'ll Value { +) -> Value<'ll> { if layout.layout.align > src_align { assert!(layout.ty.is_integral()); @@ -816,9 +816,9 @@ fn copy_to_temporary_if_more_aligned<'ll, 'tcx>( fn x86_64_sysv64_va_arg_from_memory<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - va_list_addr: &'ll Value, + va_list_addr: Value<'ll>, layout: TyAndLayout<'tcx>, -) -> &'ll Value { +) -> Value<'ll> { let dl = bx.cx.data_layout(); let ptr_align_abi = dl.data_layout().pointer_align(); @@ -855,9 +855,9 @@ fn x86_64_sysv64_va_arg_from_memory<'ll, 'tcx>( fn emit_hexagon_va_arg_musl<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - list: OperandRef<'tcx, &'ll Value>, + list: OperandRef<'tcx, Value<'ll>>, layout: TyAndLayout<'tcx>, -) -> &'ll Value { +) -> Value<'ll> { // Implementation of va_arg for Hexagon musl target. // Based on LLVM's HexagonBuiltinVaList implementation. // @@ -934,9 +934,9 @@ fn emit_hexagon_va_arg_musl<'ll, 'tcx>( fn emit_hexagon_va_arg_bare_metal<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - list: OperandRef<'tcx, &'ll Value>, + list: OperandRef<'tcx, Value<'ll>>, layout: TyAndLayout<'tcx>, -) -> &'ll Value { +) -> Value<'ll> { // Implementation of va_arg for Hexagon bare-metal (non-musl) targets. // Based on LLVM's EmitVAArgForHexagon implementation. // @@ -971,9 +971,9 @@ fn emit_hexagon_va_arg_bare_metal<'ll, 'tcx>( fn emit_xtensa_va_arg<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - list: OperandRef<'tcx, &'ll Value>, + list: OperandRef<'tcx, Value<'ll>>, layout: TyAndLayout<'tcx>, -) -> &'ll Value { +) -> Value<'ll> { // Implementation of va_arg for Xtensa. There doesn't seem to be an authoritative source for // this, other than "what GCC does". // @@ -1072,9 +1072,9 @@ fn emit_xtensa_va_arg<'ll, 'tcx>( /// pub(super) fn emit_va_arg<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, - addr: OperandRef<'tcx, &'ll Value>, + addr: OperandRef<'tcx, Value<'ll>>, layout: TyAndLayout<'tcx>, -) -> &'ll Value { +) -> Value<'ll> { // Some ABIs have special behavior for zero-sized types. currently `VaArgSafe` is not // implemented for any zero-sized types, so this assert should always hold. assert!(!layout.is_zst()); diff --git a/compiler/rustc_codegen_llvm/src/value.rs b/compiler/rustc_codegen_llvm/src/value.rs index 37f05f10c50cd..221b51851fa30 100644 --- a/compiler/rustc_codegen_llvm/src/value.rs +++ b/compiler/rustc_codegen_llvm/src/value.rs @@ -1,27 +1,12 @@ -use std::hash::{Hash, Hasher}; -use std::{fmt, ptr}; +use std::fmt; use crate::llvm::{self, Value}; -impl PartialEq for Value { - fn eq(&self, other: &Self) -> bool { - ptr::eq(self, other) - } -} - -impl Eq for Value {} - -impl Hash for Value { - fn hash(&self, hasher: &mut H) { - (self as *const Self).hash(hasher); - } -} - -impl fmt::Debug for Value { +impl<'ll> fmt::Debug for Value<'ll> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str( &llvm::build_string(|s| unsafe { - llvm::LLVMRustWriteValueToString(self, s); + llvm::LLVMRustWriteValueToString(*self, s); }) .expect("non-UTF8 value description from LLVM"), ) diff --git a/compiler/rustc_const_eval/src/interpret/call.rs b/compiler/rustc_const_eval/src/interpret/call.rs index bd3b17b9717b9..5984448fcabdb 100644 --- a/compiler/rustc_const_eval/src/interpret/call.rs +++ b/compiler/rustc_const_eval/src/interpret/call.rs @@ -842,7 +842,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> { | ty::InstanceKind::Shim(ty::ShimKind::FnPtr(..)) | ty::InstanceKind::Shim(ty::ShimKind::DropGlue(..)) | ty::InstanceKind::Shim(ty::ShimKind::Clone(..)) - | ty::InstanceKind::Shim(ty::ShimKind::FnPtrAsPtr(..)) + | ty::InstanceKind::Shim(ty::ShimKind::FnAddrAsPtr(..)) | ty::InstanceKind::Shim(ty::ShimKind::FnPtrFromPtr(..)) | ty::InstanceKind::Shim(ty::ShimKind::ThreadLocal(..)) | ty::InstanceKind::Shim(ty::ShimKind::AsyncDropGlueCtor(..)) diff --git a/compiler/rustc_data_structures/src/binary_search_util/mod.rs b/compiler/rustc_data_structures/src/binary_search_util/mod.rs deleted file mode 100644 index 1c6e227cec408..0000000000000 --- a/compiler/rustc_data_structures/src/binary_search_util/mod.rs +++ /dev/null @@ -1,27 +0,0 @@ -#[cfg(test)] -mod tests; - -/// Uses a sorted slice `data: &[E]` as a kind of "multi-map". The -/// `key_fn` extracts a key of type `K` from the data, and this -/// function finds the range of elements that match the key. `data` -/// must have been sorted as if by a call to `sort_by_key` for this to -/// work. -pub fn binary_search_slice<'d, E, K>(data: &'d [E], key_fn: impl Fn(&E) -> K, key: &K) -> &'d [E] -where - K: Ord, -{ - let size = data.len(); - let start = data.partition_point(|x| key_fn(x) < *key); - // At this point `start` either points at the first entry with equal or - // greater key or is equal to `size` in case all elements have smaller keys - if start == size || key_fn(&data[start]) != *key { - return &[]; - }; - - // Find the first entry with key > `key`. Skip `start` entries since - // key_fn(&data[start]) == *key - let offset = start + 1; - let end = data[offset..].partition_point(|x| key_fn(x) <= *key) + offset; - - &data[start..end] -} diff --git a/compiler/rustc_data_structures/src/binary_search_util/tests.rs b/compiler/rustc_data_structures/src/binary_search_util/tests.rs deleted file mode 100644 index d74febb5c0fc4..0000000000000 --- a/compiler/rustc_data_structures/src/binary_search_util/tests.rs +++ /dev/null @@ -1,23 +0,0 @@ -use super::*; - -type Element = (usize, &'static str); - -fn test_map() -> Vec { - let mut data = vec![(3, "three-a"), (0, "zero"), (3, "three-b"), (22, "twenty-two")]; - data.sort_by_key(get_key); - data -} - -fn get_key(data: &Element) -> usize { - data.0 -} - -#[test] -fn binary_search_slice_test() { - let map = test_map(); - assert_eq!(binary_search_slice(&map, get_key, &0), &[(0, "zero")]); - assert_eq!(binary_search_slice(&map, get_key, &1), &[]); - assert_eq!(binary_search_slice(&map, get_key, &3), &[(3, "three-a"), (3, "three-b")]); - assert_eq!(binary_search_slice(&map, get_key, &22), &[(22, "twenty-two")]); - assert_eq!(binary_search_slice(&map, get_key, &23), &[]); -} diff --git a/compiler/rustc_data_structures/src/fingerprint.rs b/compiler/rustc_data_structures/src/fingerprint.rs index 1855d1ff921fc..3ac54ff1a2100 100644 --- a/compiler/rustc_data_structures/src/fingerprint.rs +++ b/compiler/rustc_data_structures/src/fingerprint.rs @@ -3,7 +3,9 @@ use std::hash::{Hash, Hasher}; use rustc_hashes::Hash64; use rustc_serialize::{Decodable, Decoder, Encodable, Encoder}; -use crate::stable_hash::{FromStableHash, StableHasherHash, impl_stable_traits_for_trivial_type}; +use crate::stable_hash::{ + FromStableHash, StableHash, StableHashCtxt, StableHasher, StableHasherHash, +}; #[cfg(test)] mod tests; @@ -165,7 +167,13 @@ impl FromStableHash for Fingerprint { } } -impl_stable_traits_for_trivial_type!(Fingerprint); +impl StableHash for Fingerprint { + fn stable_hash(&self, hcx: &mut Hcx, hasher: &mut StableHasher) { + let &Fingerprint(a, b) = self; + a.stable_hash(hcx, hasher); + b.stable_hash(hcx, hasher); + } +} impl Encodable for Fingerprint { #[inline] diff --git a/compiler/rustc_data_structures/src/lib.rs b/compiler/rustc_data_structures/src/lib.rs index 7f82aeb0cbc63..747e36f382a4e 100644 --- a/compiler/rustc_data_structures/src/lib.rs +++ b/compiler/rustc_data_structures/src/lib.rs @@ -10,8 +10,8 @@ #![allow(internal_features)] #![allow(rustc::default_hash_types)] #![allow(rustc::potential_query_instability)] +#![cfg_attr(bootstrap, feature(pattern_type_macro))] #![cfg_attr(bootstrap, feature(ptr_alignment_type))] -#![cfg_attr(bootstrap, feature(unwrap_infallible))] #![cfg_attr(test, feature(test))] #![deny(unsafe_op_in_unsafe_fn)] #![feature(allocator_ext)] @@ -27,7 +27,6 @@ #![feature(min_specialization)] #![feature(negative_impls)] #![feature(nonzero_internals)] -#![feature(pattern_type_macro)] #![feature(pattern_types)] #![feature(rustc_attrs)] #![feature(sized_hierarchy)] @@ -53,7 +52,6 @@ pub use rustc_index::static_assert_size; pub use {either, indexmap, smallvec, thin_vec}; pub mod aligned; pub mod base_n; -pub mod binary_search_util; pub mod fingerprint; pub mod flat_map_in_place; pub mod flock; diff --git a/compiler/rustc_data_structures/src/stable_hash.rs b/compiler/rustc_data_structures/src/stable_hash.rs index 57f5901656827..7d41ca4a4dfdb 100644 --- a/compiler/rustc_data_structures/src/stable_hash.rs +++ b/compiler/rustc_data_structures/src/stable_hash.rs @@ -1,10 +1,14 @@ -use std::hash::{BuildHasher, Hash, Hasher}; +use std::ffi::OsStr; +use std::hash::{BuildHasher, Hasher}; use std::marker::PhantomData; use std::num::NonZero; -use rustc_index::bit_set::{self, DenseBitSet}; -use rustc_index::{Idx, IndexSlice, IndexVec}; +use rustc_hashes::{Hash64, Hash128}; +use rustc_index::{Idx, IndexSlice, IndexVec, bit_set}; use rustc_macros::StableHash; +pub use rustc_stable_hash::{ + FromStableHash, SipHasher128Hash as StableHasherHash, StableSipHasher128 as StableHasher, +}; use smallvec::SmallVec; use thin_vec::ThinVec; @@ -13,11 +17,6 @@ use crate::fingerprint::Fingerprint; #[cfg(test)] mod tests; -use rustc_hashes::{Hash64, Hash128}; -pub use rustc_stable_hash::{ - FromStableHash, SipHasher128Hash as StableHasherHash, StableSipHasher128 as StableHasher, -}; - /// This trait lets `StableHash` and `derive(StableHash)` be used in /// this crate (and other crates upstream of `rustc_middle`), while leaving /// certain operations to be defined in `rustc_middle` where more things are @@ -186,29 +185,20 @@ impl StableCompare for T { } } -/// Implement StableHash by just calling `Hash::hash()`. Also implement `StableOrd` for the type -/// since that has the same requirements. -/// -/// **WARNING** This is only valid for types that *really* don't need any context for fingerprinting. -/// But it is easy to misuse this macro (see [#96013](https://github.com/rust-lang/rust/issues/96013) -/// for examples). Therefore this macro is not exported and should only be used in the limited cases -/// here in this module. -/// -/// Use `#[derive(StableHash)]` instead. -macro_rules! impl_stable_traits_for_trivial_type { - ($t:ty) => { - impl $crate::stable_hash::StableHash for $t { +/// Implements [`StableHash`] and [`StableOrd`] for a primitive integer type. +/// The stable-hash impl calls the corresponding `Hasher::write_*` method. +macro_rules! impl_stable_traits_for_int { + ( + $ty:ty, $write_ty_method:ident + ) => { + impl StableHash for $ty { #[inline] - fn stable_hash( - &self, - _: &mut Hcx, - hasher: &mut $crate::stable_hash::StableHasher, - ) { - ::std::hash::Hash::hash(self, hasher); + fn stable_hash(&self, _: &mut Hcx, hasher: &mut StableHasher) { + hasher.$write_ty_method(*self); } } - impl $crate::stable_hash::StableOrd for $t { + impl StableOrd for $ty { const CAN_USE_UNSTABLE_SORT: bool = true; // Encoding and decoding doesn't change the bytes of trivial types @@ -218,34 +208,42 @@ macro_rules! impl_stable_traits_for_trivial_type { }; } -pub(crate) use impl_stable_traits_for_trivial_type; - -impl_stable_traits_for_trivial_type!(i8); -impl_stable_traits_for_trivial_type!(i16); -impl_stable_traits_for_trivial_type!(i32); -impl_stable_traits_for_trivial_type!(i64); -impl_stable_traits_for_trivial_type!(isize); +impl_stable_traits_for_int!(u8, write_u8); +impl_stable_traits_for_int!(u16, write_u16); +impl_stable_traits_for_int!(u32, write_u32); +impl_stable_traits_for_int!(u64, write_u64); +impl_stable_traits_for_int!(u128, write_u128); +impl_stable_traits_for_int!(usize, write_usize); -impl_stable_traits_for_trivial_type!(u8); -impl_stable_traits_for_trivial_type!(u16); -impl_stable_traits_for_trivial_type!(u32); -impl_stable_traits_for_trivial_type!(u64); -impl_stable_traits_for_trivial_type!(usize); +impl_stable_traits_for_int!(i8, write_i8); +impl_stable_traits_for_int!(i16, write_i16); +impl_stable_traits_for_int!(i32, write_i32); +impl_stable_traits_for_int!(i64, write_i64); +impl_stable_traits_for_int!(i128, write_i128); +impl_stable_traits_for_int!(isize, write_isize); -impl_stable_traits_for_trivial_type!(u128); -impl_stable_traits_for_trivial_type!(i128); +impl StableHash for char { + fn stable_hash(&self, hcx: &mut Hcx, hasher: &mut StableHasher) { + u32::from(*self).stable_hash(hcx, hasher); + } +} -impl_stable_traits_for_trivial_type!(char); -impl_stable_traits_for_trivial_type!(()); +impl StableHash for () { + fn stable_hash(&self, _hcx: &mut Hcx, _hasher: &mut StableHasher) { + // No need to hash anything for the unit type. + } +} -impl_stable_traits_for_trivial_type!(Hash64); +impl StableHash for Hash64 { + fn stable_hash(&self, hcx: &mut Hcx, hasher: &mut StableHasher) { + self.as_u64().stable_hash(hcx, hasher); + } +} -// We need a custom impl as the default hash function will only hash half the bits. For stable -// hashing we want to hash the full 128-bit hash. impl StableHash for Hash128 { #[inline] - fn stable_hash(&self, _: &mut Hcx, hasher: &mut StableHasher) { - self.as_u128().hash(hasher); + fn stable_hash(&self, hcx: &mut Hcx, hasher: &mut StableHasher) { + self.as_u128().stable_hash(hcx, hasher); } } @@ -394,7 +392,7 @@ impl StableHash for Vec { impl StableHash for indexmap::IndexMap where - K: StableHash + Eq + Hash, + K: StableHash, V: StableHash, R: BuildHasher, { @@ -409,7 +407,7 @@ where impl StableHash for indexmap::IndexSet where - K: StableHash + Eq + Hash, + K: StableHash, R: BuildHasher, { #[inline] @@ -609,19 +607,23 @@ where } } -impl StableHash for DenseBitSet { +impl StableHash for bit_set::DenseBitSet { fn stable_hash(&self, _hcx: &mut Hcx, hasher: &mut StableHasher) { - ::std::hash::Hash::hash(self, hasher); + bit_set::DenseBitSet::stable_hash_inner(self, hasher); } } impl StableHash for bit_set::BitMatrix { fn stable_hash(&self, _hcx: &mut Hcx, hasher: &mut StableHasher) { - ::std::hash::Hash::hash(self, hasher); + bit_set::BitMatrix::stable_hash_inner(self, hasher); } } -impl_stable_traits_for_trivial_type!(::std::ffi::OsStr); +impl StableHash for OsStr { + fn stable_hash(&self, hcx: &mut Hcx, hasher: &mut StableHasher) { + self.as_encoded_bytes().stable_hash(hcx, hasher); + } +} impl StableHash for std::path::Path { fn stable_hash(&self, hcx: &mut Hcx, hasher: &mut StableHasher) { diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs index af1e4be5e8399..326014b2699db 100644 --- a/compiler/rustc_expand/src/expand.rs +++ b/compiler/rustc_expand/src/expand.rs @@ -41,7 +41,6 @@ use crate::diagnostics::{ GlobDelegationTraitlessQpath, IncompleteParse, RecursionLimitReached, RemoveExprNotSupported, UnsupportedKeyValue, WrongFragmentKind, }; -use crate::mbe::diagnostics::annotate_err_with_kind; use crate::module::{ DirOwnership, ParsedExternalMod, mod_dir_path, mod_file_path_from_attr, parse_external_mod, }; @@ -1067,7 +1066,6 @@ impl<'a, 'b> MacroExpander<'a, 'b> { if err.span.is_dummy() { err.span(span); } - annotate_err_with_kind(&mut err, kind, span); let guar = err.emit_err(); self.cx.macro_error_and_trace_macros_diag(); kind.dummy(span, guar) diff --git a/compiler/rustc_expand/src/mbe/diagnostics.rs b/compiler/rustc_expand/src/mbe/diagnostics.rs index c724857d572ec..281f55f8ec090 100644 --- a/compiler/rustc_expand/src/mbe/diagnostics.rs +++ b/compiler/rustc_expand/src/mbe/diagnostics.rs @@ -434,8 +434,8 @@ pub(super) fn emit_frag_parse_err( } } }, - _ => annotate_err_with_kind(&mut e, kind, site_span), - }; + _ => {} + } if parser.token.kind == token::Dollar { let dollar_span = parser.token.span; @@ -504,18 +504,6 @@ pub(super) fn emit_frag_parse_err( e.emit_err() } -pub(crate) fn annotate_err_with_kind(err: &mut Diag<'_>, kind: AstFragmentKind, span: Span) { - match kind { - AstFragmentKind::Ty => { - err.span_label(span, "this macro call doesn't expand to a type"); - } - AstFragmentKind::Pat => { - err.span_label(span, "this macro call doesn't expand to a pattern"); - } - _ => {} - }; -} - #[derive(Subdiagnostic)] enum ExplainDocComment { #[label( diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs index 4c7f053c1cd53..fa9be8e57f1b6 100644 --- a/compiler/rustc_feature/src/accepted.rs +++ b/compiler/rustc_feature/src/accepted.rs @@ -350,7 +350,7 @@ declare_features! ( /// Allows using multiple nested field accesses in offset_of! (accepted, offset_of_nested, "1.82.0", Some(120140)), /// Allows using `#[optimize(X)]`. - (accepted, optimize_attribute, "CURRENT_RUSTC_VERSION", Some(54882)), + (accepted, optimize_attribute, "1.101.0", Some(54882)), /// Allows the use of or-patterns (e.g., `0 | 1`). (accepted, or_patterns, "1.53.0", Some(54883)), /// Allows using `+bundle,+whole-archive` link modifiers with native libs. diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs index 57e9d1d5e137d..6595db1bdd5b0 100644 --- a/compiler/rustc_feature/src/unstable.rs +++ b/compiler/rustc_feature/src/unstable.rs @@ -309,7 +309,7 @@ declare_features! ( /// Allows using the `#[fundamental]` attribute. (unstable, fundamental, "1.0.0", Some(29635)), /// Allows internal syntax. - (internal, internal_syntax, "CURRENT_RUSTC_VERSION", Some(110680)), + (internal, internal_syntax, "1.101.0", Some(110680)), /// Allows using `#[link_name="llvm.*"]`. (internal, link_llvm_intrinsics, "1.0.0", Some(29602)), /// Allows using the `#[linkage = ".."]` attribute. @@ -318,8 +318,6 @@ declare_features! ( (internal, needs_panic_runtime, "1.10.0", Some(32837)), /// Allows using the `#![panic_runtime]` attribute. (internal, panic_runtime, "1.10.0", Some(32837)), - /// Allows using pattern types. - (internal, pattern_types, "1.79.0", Some(123646)), /// Allows `repr(simd)` and importing the various simd intrinsics. (internal, repr_simd, "1.4.0", Some(27731)), /// Allows using compiler's own crates. @@ -552,17 +550,17 @@ declare_features! ( /// Traits for function pointers and items (unstable, fn_static, "1.100.0", Some(148768)), /// Allows using forced keywords `k#fn`. - (unstable, forced_keywords, "CURRENT_RUSTC_VERSION", Some(153839)), + (unstable, forced_keywords, "1.101.0", Some(153839)), /// The `Forget` autotrait. - (incomplete, forget_trait, "CURRENT_RUSTC_VERSION", Some(165370)), + (incomplete, forget_trait, "1.101.0", Some(165370)), /// Allows impls for the Freeze trait. (internal, freeze_impls, "1.78.0", Some(121675)), /// Frontmatter `---` blocks for use by external tools. (unstable, frontmatter, "1.88.0", Some(136889)), /// Allow function args to be const generics - (incomplete, function_arg_const_generics, "CURRENT_RUSTC_VERSION", Some(163261)), + (incomplete, function_arg_const_generics, "1.101.0", Some(163261)), /// Allows using ADTs in directly represented generic const args. - (incomplete, gca_adts, "CURRENT_RUSTC_VERSION", Some(163420)), + (incomplete, gca_adts, "1.101.0", Some(163420)), /// Allows using generics in more complex const expressions, based on definitional equality. (incomplete, gca_const_items, "1.95.0", Some(151972)), /// Allows directly represented gca_const_items without the `gca!` macro. @@ -636,7 +634,7 @@ declare_features! ( (unstable, macro_metavar_expr_concat, "1.81.0", Some(124225)), /// Allows explicitly marking type aliases as unchecked / opting type aliases /// out of being checked even if `checked_type_aliases` is enabled or they're a TAIT. - (unstable, marked_unchecked_type_aliases, "CURRENT_RUSTC_VERSION", Some(112792)), + (unstable, marked_unchecked_type_aliases, "1.101.0", Some(112792)), /// Allows `#[marker]` on certain traits allowing overlapping implementations. (unstable, marker_trait_attr, "1.30.0", Some(29864)), /// Allows additional const parameter types, such as [u8; 10] or user defined types. @@ -651,9 +649,9 @@ declare_features! ( /// Allows qualified paths in struct expressions, struct patterns and tuple struct patterns. (unstable, more_qualified_paths, "1.54.0", Some(86935)), /// The `movdir64b` target feature on x86. - (unstable, movdir64b_target_feature, "CURRENT_RUSTC_VERSION", Some(163741)), + (unstable, movdir64b_target_feature, "1.101.0", Some(163741)), /// The `movdiri` target feature on x86. - (unstable, movdiri_target_feature, "CURRENT_RUSTC_VERSION", Some(163741)), + (unstable, movdiri_target_feature, "1.101.0", Some(163741)), /// Allows `move(expr)` in closures. (incomplete, move_expr, "1.97.0", Some(155050)), /// The `Move` autotrait. @@ -784,8 +782,6 @@ declare_features! ( (internal, unsized_fn_params, "1.49.0", Some(48055)), /// Allows using the `#[used(linker)]` (or `#[used(compiler)]`) attribute. (unstable, used_with_arg, "1.60.0", Some(93798)), - /// Allows view types. - (unstable, view_types, "1.97.0", Some(155938)), /// Target features on wasm. (unstable, wasm_target_feature, "1.30.0", Some(150260)), /// Allows use of attributes in `where` clauses. diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs index f4b4e50400530..d3ebb2b173da7 100644 --- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs +++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs @@ -2681,6 +2681,12 @@ fn lint_redundant_lifetimes<'tcx>( owner_id: LocalDefId, outlives_env: &OutlivesEnvironment<'tcx>, ) { + // Items produced by external macros (e.g. derived impls) reuse the lifetime spans of the + // macro input, so the usual external macro check on the lint span does not catch them. + if tcx.def_span(owner_id).in_external_macro(tcx.sess.source_map()) { + return; + } + let def_kind = tcx.def_kind(owner_id); match def_kind { DefKind::Struct diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs index 5adba33a87ab3..369511aa9c671 100644 --- a/compiler/rustc_hir_analysis/src/lib.rs +++ b/compiler/rustc_hir_analysis/src/lib.rs @@ -56,7 +56,6 @@ This API is completely unstable and subject to change. */ // tidy-alphabetical-start -#![cfg_attr(bootstrap, feature(unwrap_infallible))] #![feature(default_field_values)] #![feature(gen_blocks)] #![feature(iter_intersperse)] diff --git a/compiler/rustc_index/src/bit_set.rs b/compiler/rustc_index/src/bit_set.rs index b1b26bfce7b2f..f69c4e3ae77f0 100644 --- a/compiler/rustc_index/src/bit_set.rs +++ b/compiler/rustc_index/src/bit_set.rs @@ -75,7 +75,7 @@ fn inclusive_start_end( /// will panic if the bitsets have differing domain sizes. /// #[cfg_attr(feature = "nightly", derive(Decodable_NoContext, Encodable_NoContext))] -#[derive(Eq, PartialEq, Hash)] +#[derive(Eq, PartialEq)] pub struct DenseBitSet { domain_size: usize, words: Box<[Word]>, @@ -114,6 +114,14 @@ impl DenseBitSet { result } + /// Should only be called by `impl StableHash for DenseBitSet`. + pub fn stable_hash_inner(this: &Self, hasher: &mut impl std::hash::Hasher) { + let &DenseBitSet { domain_size, ref words, marker: PhantomData } = this; + hasher.write_usize(domain_size); + // No need to hash `words.len()`, since it is derived from the domain size. + words.iter().for_each(|&word| hasher.write_u64(word)); + } + /// Clear all elements. #[inline] pub fn clear(&mut self) { @@ -1306,7 +1314,7 @@ impl GrowableBitSet { /// All operations that involve a row and/or column index will panic if the /// index exceeds the relevant bound. #[cfg_attr(feature = "nightly", derive(Decodable_NoContext, Encodable_NoContext))] -#[derive(Clone, Eq, PartialEq, Hash)] +#[derive(Clone, Eq, PartialEq)] pub struct BitMatrix { num_rows: usize, num_columns: usize, @@ -1341,6 +1349,15 @@ impl BitMatrix { } } + /// Should only be called by `impl StableHash for BitMatrix`. + pub fn stable_hash_inner(this: &Self, hasher: &mut impl std::hash::Hasher) { + let &BitMatrix { num_rows, num_columns, ref words, marker: PhantomData } = this; + hasher.write_usize(num_rows); + hasher.write_usize(num_columns); + // No need to hash `words.len()`, since it is derived from the matrix dimensions. + words.iter().for_each(|&word| hasher.write_u64(word)); + } + pub fn rows(&self) -> impl Iterator { (0..self.num_rows).map(R::new) } diff --git a/compiler/rustc_index_macros/src/lib.rs b/compiler/rustc_index_macros/src/lib.rs index b0bc40a9d8b1a..86681332ceb47 100644 --- a/compiler/rustc_index_macros/src/lib.rs +++ b/compiler/rustc_index_macros/src/lib.rs @@ -41,7 +41,7 @@ mod newtype; rustc_attrs, trusted_step, pattern_types, - pattern_type_macro, + pattern_type_macro, // cfg(bootstrap) FIXME: remove on bump structural_match, ) )] diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs index aa69776374322..a376252ad1038 100644 --- a/compiler/rustc_lint/src/builtin.rs +++ b/compiler/rustc_lint/src/builtin.rs @@ -1977,204 +1977,202 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitOutlivesRequirements { use rustc_middle::middle::resolve_bound_vars::ResolvedArg; let def_id = item.owner_id.def_id; - if let hir::ItemKind::Struct(_, generics, _) - | hir::ItemKind::Enum(_, generics, _) - | hir::ItemKind::Union(_, generics, _) = item.kind - { - let inferred_outlives = cx.tcx.inferred_outlives_of(def_id); - if inferred_outlives.is_empty() { - return; + + let generics = match item.kind { + hir::ItemKind::Struct(_, generics, _) + | hir::ItemKind::Enum(_, generics, _) + | hir::ItemKind::Union(_, generics, _) => generics, + hir::ItemKind::TyAlias(_, generics, _) if cx.tcx.type_alias_is_checked(def_id) => { + generics } + _ => return, + }; + + let inferred_outlives = cx.tcx.inferred_outlives_of(def_id); + if inferred_outlives.is_empty() { + return; + } - let ty_generics = cx.tcx.generics_of(def_id); - let num_where_predicates = generics - .predicates - .iter() - .filter(|predicate| predicate.kind.in_where_clause()) - .count(); - - let mut bound_count = 0; - let mut lint_spans = Vec::new(); - let mut where_lint_spans = Vec::new(); - let mut dropped_where_predicate_count = 0; - for (i, where_predicate) in generics.predicates.iter().enumerate() { - let (relevant_lifetimes, bounds, predicate_span, in_where_clause) = - match where_predicate.kind { - hir::WherePredicateKind::RegionPredicate(predicate) => { - if let Some(ResolvedArg::EarlyBound(region_def_id)) = - cx.tcx.named_bound_var(predicate.lifetime.hir_id) - { + let ty_generics = cx.tcx.generics_of(def_id); + let num_where_predicates = + generics.predicates.iter().filter(|predicate| predicate.kind.in_where_clause()).count(); + + let mut bound_count = 0; + let mut lint_spans = Vec::new(); + let mut where_lint_spans = Vec::new(); + let mut dropped_where_predicate_count = 0; + for (i, where_predicate) in generics.predicates.iter().enumerate() { + let (relevant_lifetimes, bounds, predicate_span, in_where_clause) = + match where_predicate.kind { + hir::WherePredicateKind::RegionPredicate(predicate) => { + if let Some(ResolvedArg::EarlyBound(region_def_id)) = + cx.tcx.named_bound_var(predicate.lifetime.hir_id) + { + ( + Self::lifetimes_outliving_lifetime( + cx.tcx, + // don't warn if the inferred span actually came from the predicate we're looking at + // this happens if the type is recursively defined + inferred_outlives + .iter() + .filter(|(_, span)| !where_predicate.span.contains(*span)), + item.owner_id.def_id, + region_def_id, + ), + &predicate.bounds, + where_predicate.span, + predicate.in_where_clause, + ) + } else { + continue; + } + } + hir::WherePredicateKind::BoundPredicate(predicate) => { + // FIXME we can also infer bounds on associated types, + // and should check for them here. + match predicate.bounded_ty.kind { + hir::TyKind::Path(hir::QPath::Resolved(None, path)) => { + let Res::Def(DefKind::TyParam, def_id) = path.res else { + continue; + }; + let index = ty_generics.param_def_id_to_index[&def_id]; + // Removing a `T: 'r` outlives bound can silently change + // the object lifetime default for `Struct<'r, dyn Trait>` + // (RFC 599): the explicit bound sets the default to `'r`, + // so removing it may change it to `'static` (or cause an + // ambiguity error if there is no unique default). Only + // suppress the lint for non-higher-ranked predicates when + // T is not `Sized` (i.e. can hold trait object types). + // Higher-ranked predicates (`for<'x> T: 'r`) are excluded + // from RFC 599 object lifetime defaulting and are always + // safe to remove. + if predicate.bound_generic_params.is_empty() { + let ty_param = &ty_generics.own_params[index as usize]; + let param_ty = + Ty::new_param(cx.tcx, ty_param.index, ty_param.name); + if !param_ty.is_sized(cx.tcx, cx.typing_env()) { + continue; + } + } ( - Self::lifetimes_outliving_lifetime( - cx.tcx, + Self::lifetimes_outliving_type( // don't warn if the inferred span actually came from the predicate we're looking at // this happens if the type is recursively defined inferred_outlives.iter().filter(|(_, span)| { !where_predicate.span.contains(*span) }), - item.owner_id.def_id, - region_def_id, + index, ), &predicate.bounds, where_predicate.span, - predicate.in_where_clause, + predicate.origin == PredicateOrigin::WhereClause, ) - } else { - continue; } - } - hir::WherePredicateKind::BoundPredicate(predicate) => { - // FIXME we can also infer bounds on associated types, - // and should check for them here. - match predicate.bounded_ty.kind { - hir::TyKind::Path(hir::QPath::Resolved(None, path)) => { - let Res::Def(DefKind::TyParam, def_id) = path.res else { - continue; - }; - let index = ty_generics.param_def_id_to_index[&def_id]; - // Removing a `T: 'r` outlives bound can silently change - // the object lifetime default for `Struct<'r, dyn Trait>` - // (RFC 599): the explicit bound sets the default to `'r`, - // so removing it may change it to `'static` (or cause an - // ambiguity error if there is no unique default). Only - // suppress the lint for non-higher-ranked predicates when - // T is not `Sized` (i.e. can hold trait object types). - // Higher-ranked predicates (`for<'x> T: 'r`) are excluded - // from RFC 599 object lifetime defaulting and are always - // safe to remove. - if predicate.bound_generic_params.is_empty() { - let ty_param = &ty_generics.own_params[index as usize]; - let param_ty = - Ty::new_param(cx.tcx, ty_param.index, ty_param.name); - if !param_ty.is_sized(cx.tcx, cx.typing_env()) { - continue; - } - } - ( - Self::lifetimes_outliving_type( - // don't warn if the inferred span actually came from the predicate we're looking at - // this happens if the type is recursively defined - inferred_outlives.iter().filter(|(_, span)| { - !where_predicate.span.contains(*span) - }), - index, - ), - &predicate.bounds, - where_predicate.span, - predicate.origin == PredicateOrigin::WhereClause, - ) - } - _ => { - continue; - } + _ => { + continue; } } - }; - if relevant_lifetimes.is_empty() { - continue; - } + } + }; + if relevant_lifetimes.is_empty() { + continue; + } - let bound_spans = self.collect_outlives_bound_spans( - cx.tcx, - bounds, - &relevant_lifetimes, - predicate_span, - item.owner_id.to_def_id(), - ); - bound_count += bound_spans.len(); + let bound_spans = self.collect_outlives_bound_spans( + cx.tcx, + bounds, + &relevant_lifetimes, + predicate_span, + item.owner_id.to_def_id(), + ); + bound_count += bound_spans.len(); - let drop_predicate = bound_spans.len() == bounds.len(); - if drop_predicate && in_where_clause { - dropped_where_predicate_count += 1; - } + let drop_predicate = bound_spans.len() == bounds.len(); + if drop_predicate && in_where_clause { + dropped_where_predicate_count += 1; + } - if drop_predicate { - if !in_where_clause { - lint_spans.push(predicate_span); - } else if predicate_span.from_expansion() { - // Don't try to extend the span if it comes from a macro expansion. + if drop_predicate { + if !in_where_clause { + lint_spans.push(predicate_span); + } else if predicate_span.from_expansion() { + // Don't try to extend the span if it comes from a macro expansion. + where_lint_spans.push(predicate_span); + } else if i + 1 < num_where_predicates { + // If all the bounds on a predicate were inferable and there are + // further predicates, we want to eat the trailing comma. + let next_predicate_span = generics.predicates[i + 1].span; + if next_predicate_span.from_expansion() { where_lint_spans.push(predicate_span); - } else if i + 1 < num_where_predicates { - // If all the bounds on a predicate were inferable and there are - // further predicates, we want to eat the trailing comma. - let next_predicate_span = generics.predicates[i + 1].span; - if next_predicate_span.from_expansion() { - where_lint_spans.push(predicate_span); - } else { - where_lint_spans - .push(predicate_span.to(next_predicate_span.shrink_to_lo())); - } } else { - // Eat the optional trailing comma after the last predicate. - let where_span = generics.where_clause_span; - if where_span.from_expansion() { - where_lint_spans.push(predicate_span); - } else { - where_lint_spans.push(predicate_span.to(where_span.shrink_to_hi())); - } + where_lint_spans + .push(predicate_span.to(next_predicate_span.shrink_to_lo())); } } else { - where_lint_spans.extend(self.consolidate_outlives_bound_spans( - predicate_span.shrink_to_lo(), - bounds, - bound_spans, - )); + // Eat the optional trailing comma after the last predicate. + let where_span = generics.where_clause_span; + if where_span.from_expansion() { + where_lint_spans.push(predicate_span); + } else { + where_lint_spans.push(predicate_span.to(where_span.shrink_to_hi())); + } } + } else { + where_lint_spans.extend(self.consolidate_outlives_bound_spans( + predicate_span.shrink_to_lo(), + bounds, + bound_spans, + )); } + } - // If all predicates in where clause are inferable, drop the entire clause - // (including the `where`) - if generics.has_where_clause_predicates - && dropped_where_predicate_count == num_where_predicates - { - let where_span = generics.where_clause_span; - // Extend the where clause back to the closing `>` of the - // generics, except for tuple struct, which have the `where` - // after the fields of the struct. - let full_where_span = - if let hir::ItemKind::Struct(_, _, hir::VariantData::Tuple(..)) = item.kind { - where_span - } else { - generics.span.shrink_to_hi().to(where_span) - }; - - // Due to macro expansions, the `full_where_span` might not actually contain all - // predicates. - if where_lint_spans.iter().all(|&sp| full_where_span.contains(sp)) { - lint_spans.push(full_where_span); - } else { - lint_spans.extend(where_lint_spans); - } + // If all predicates in the where clause are inferable, drop the entire clause + // (including the `where`) + if generics.has_where_clause_predicates + && dropped_where_predicate_count == num_where_predicates + { + let where_span = generics.where_clause_span; + let full_where_span = cx + .sess() + .source_map() + .span_extend_prev_while(where_span, char::is_whitespace) + .unwrap_or(where_span); + + // Due to macro expansions, the `full_where_span` might not actually contain all + // predicates. + if where_lint_spans.iter().all(|&sp| full_where_span.contains(sp)) { + lint_spans.push(full_where_span); } else { lint_spans.extend(where_lint_spans); } + } else { + lint_spans.extend(where_lint_spans); + } - if !lint_spans.is_empty() { - // Do not automatically delete outlives requirements from macros. - let applicability = if lint_spans.iter().all(|sp| sp.can_be_used_for_suggestions()) - { - Applicability::MachineApplicable - } else { - Applicability::MaybeIncorrect - }; + if !lint_spans.is_empty() { + // Do not automatically delete outlives requirements from macros. + let applicability = if lint_spans.iter().all(|sp| sp.can_be_used_for_suggestions()) { + Applicability::MachineApplicable + } else { + Applicability::MaybeIncorrect + }; - // Due to macros, there might be several predicates with the same span - // and we only want to suggest removing them once. - lint_spans.sort_unstable_by_key(|span| span.lo_hi()); - lint_spans.dedup_by_key(|span| span.lo_hi()); + // Due to macros, there might be several predicates with the same span + // and we only want to suggest removing them once. + lint_spans.sort_unstable_by_key(|span| span.lo_hi()); + lint_spans.dedup_by_key(|span| span.lo_hi()); - cx.emit_span_lint( - EXPLICIT_OUTLIVES_REQUIREMENTS, - lint_spans.clone(), - BuiltinExplicitOutlives { - suggestion: BuiltinExplicitOutlivesSuggestion { - spans: lint_spans, - applicability, - count: bound_count, - }, + cx.emit_span_lint( + EXPLICIT_OUTLIVES_REQUIREMENTS, + lint_spans.clone(), + BuiltinExplicitOutlives { + suggestion: BuiltinExplicitOutlivesSuggestion { + spans: lint_spans, + applicability, + count: bound_count, }, - ); - } + }, + ); } } } diff --git a/compiler/rustc_lint/src/let_underscore.rs b/compiler/rustc_lint/src/let_underscore.rs index 07c2bf6f0ca13..7953d5afab41d 100644 --- a/compiler/rustc_lint/src/let_underscore.rs +++ b/compiler/rustc_lint/src/let_underscore.rs @@ -101,8 +101,7 @@ declare_lint! { /// of at end of scope, which is typically incorrect. /// /// ### Example - #[cfg_attr(bootstrap, doc = "```rust")] - #[cfg_attr(not(bootstrap), doc = "```rust,compile_fail")] + /// ```rust,compile_fail /// use std::mem::DropGuard; /// /// // The closure runs immediately instead of at the end of the scope, @@ -110,8 +109,7 @@ declare_lint! { /// let _ = DropGuard::new((), |_| { /// println!("cleaning up"); /// }); - #[cfg_attr(bootstrap, doc = "```")] - #[cfg_attr(not(bootstrap), doc = "```")] + /// ``` /// /// {{produces}} /// diff --git a/compiler/rustc_lint/src/unmarked_unchecked_type_aliases.rs b/compiler/rustc_lint/src/unmarked_unchecked_type_aliases.rs index 286e7f9316ce1..3d181b46eac9f 100644 --- a/compiler/rustc_lint/src/unmarked_unchecked_type_aliases.rs +++ b/compiler/rustc_lint/src/unmarked_unchecked_type_aliases.rs @@ -11,14 +11,12 @@ declare_lint! { /// /// ### Example /// - #[cfg_attr(bootstrap, doc = "```rust,ignore")] - #[cfg_attr(not(bootstrap), doc = "```rust")] + /// ```rust /// #![feature(marked_unchecked_type_aliases)] /// #![warn(unmarked_unchecked_type_aliases)] /// /// type Alias = [(); panic!()]; - #[cfg_attr(bootstrap, doc = "```")] - #[cfg_attr(not(bootstrap), doc = "```")] + /// ``` /// /// {{produces}} /// diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs index 81e586ebbc736..d6e4b3b0bac7b 100644 --- a/compiler/rustc_lint_defs/src/builtin.rs +++ b/compiler/rustc_lint_defs/src/builtin.rs @@ -6027,12 +6027,10 @@ declare_lint! { /// /// ### Example /// - #[cfg_attr(bootstrap, doc = "```rust,ignore")] - #[cfg_attr(not(bootstrap), doc = "```rust,compile_fail")] + /// ```rust,compile_fail /// #[no_link] /// extern crate std; - #[cfg_attr(bootstrap, doc = "```")] - #[cfg_attr(not(bootstrap), doc = "```")] + /// ``` /// /// {{produces}} /// diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs index 0b404cf43c80d..5d69dadf4ade0 100644 --- a/compiler/rustc_middle/src/lib.rs +++ b/compiler/rustc_middle/src/lib.rs @@ -27,7 +27,6 @@ // tidy-alphabetical-start #![allow(internal_features)] #![allow(rustc::direct_use_of_rustc_type_ir)] -#![cfg_attr(bootstrap, feature(debug_closure_helpers))] #![cfg_attr(bootstrap, feature(ptr_alignment_type))] #![cfg_attr(doc, feature(intra_doc_pointers))] #![feature(allocator_ext)] diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs index 2fc07d1c43cd3..20e9f70691b5a 100644 --- a/compiler/rustc_middle/src/mir/visit.rs +++ b/compiler/rustc_middle/src/mir/visit.rs @@ -362,7 +362,7 @@ macro_rules! make_mir_visitor { ty::InstanceKind::Shim(ty::ShimKind::FnPtr(_def_id, ty)) | ty::InstanceKind::Shim(ty::ShimKind::DropGlue(_def_id, Some(ty))) | ty::InstanceKind::Shim(ty::ShimKind::Clone(_def_id, ty)) - | ty::InstanceKind::Shim(ty::ShimKind::FnPtrAsPtr(_def_id, ty)) + | ty::InstanceKind::Shim(ty::ShimKind::FnAddrAsPtr(_def_id, ty)) | ty::InstanceKind::Shim(ty::ShimKind::FnPtrFromPtr(_def_id, ty)) | ty::InstanceKind::Shim(ty::ShimKind::AsyncDropGlue(_def_id, ty)) | ty::InstanceKind::Shim(ty::ShimKind::AsyncDropGlueCtor(_def_id, ty)) => { diff --git a/compiler/rustc_middle/src/mono.rs b/compiler/rustc_middle/src/mono.rs index afefe410d3043..21569b4d62180 100644 --- a/compiler/rustc_middle/src/mono.rs +++ b/compiler/rustc_middle/src/mono.rs @@ -548,7 +548,7 @@ impl<'tcx> CodegenUnit<'tcx> { | InstanceKind::Shim(ShimKind::DropGlue(..)) | InstanceKind::Shim(ShimKind::Clone(..)) | InstanceKind::Shim(ShimKind::ThreadLocal(..)) - | InstanceKind::Shim(ShimKind::FnPtrAsPtr(..)) + | InstanceKind::Shim(ShimKind::FnAddrAsPtr(..)) | InstanceKind::Shim(ShimKind::FnPtrFromPtr(..)) | InstanceKind::Shim(ShimKind::AsyncDropGlue(..)) | InstanceKind::Shim(ShimKind::FutureDropPoll(..)) diff --git a/compiler/rustc_middle/src/ty/context/impl_interner.rs b/compiler/rustc_middle/src/ty/context/impl_interner.rs index c71d13962bc5a..a3566aa9efd18 100644 --- a/compiler/rustc_middle/src/ty/context/impl_interner.rs +++ b/compiler/rustc_middle/src/ty/context/impl_interner.rs @@ -841,6 +841,7 @@ bidirectional_lang_item_map! { Drop, Field, Fn, + FnAddrTrait, FnMut, FnOnce, FnPtrTrait, diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs index a90de4c3baba6..ceb1d2a55823e 100644 --- a/compiler/rustc_middle/src/ty/instance.rs +++ b/compiler/rustc_middle/src/ty/instance.rs @@ -182,7 +182,7 @@ pub enum ShimKind<'tcx> { /// Automatically generated for all potentially higher-ranked `fn(I) -> R` types. /// /// The `DefId` is for `FnPtr::as_ptr`, the `Ty` is the type `T`. - FnPtrAsPtr(DefId, Ty<'tcx>), + FnAddrAsPtr(DefId, Ty<'tcx>), /// Compiler-generated `::from_ptr` implementation. /// @@ -351,7 +351,7 @@ impl<'tcx> ShimKind<'tcx> { } | ShimKind::DropGlue(def_id, _) | ShimKind::Clone(def_id, _) - | ShimKind::FnPtrAsPtr(def_id, _) + | ShimKind::FnAddrAsPtr(def_id, _) | ShimKind::FnPtrFromPtr(def_id, _) | ShimKind::FutureDropPoll(def_id, _, _) | ShimKind::AsyncDropGlue(def_id, _) @@ -374,7 +374,7 @@ impl<'tcx> ShimKind<'tcx> { | ShimKind::ConstructCoroutineInClosure { .. } | ShimKind::DropGlue(..) | ShimKind::Clone(..) - | ShimKind::FnPtrAsPtr(..) + | ShimKind::FnAddrAsPtr(..) | ShimKind::FnPtrFromPtr(..) => None, } } @@ -395,7 +395,7 @@ impl<'tcx> ShimKind<'tcx> { ShimKind::Clone(..) | ShimKind::ThreadLocal(..) | ShimKind::FnPtr(..) - | ShimKind::FnPtrAsPtr(..) + | ShimKind::FnAddrAsPtr(..) | ShimKind::FnPtrFromPtr(..) | ShimKind::DropGlue(_, Some(_)) | ShimKind::FutureDropPoll(..) diff --git a/compiler/rustc_middle/src/ty/print/mod.rs b/compiler/rustc_middle/src/ty/print/mod.rs index afb0bc1705f91..7c62c5a5c4f17 100644 --- a/compiler/rustc_middle/src/ty/print/mod.rs +++ b/compiler/rustc_middle/src/ty/print/mod.rs @@ -400,7 +400,7 @@ impl<'tcx, P: Printer<'tcx> + std::fmt::Write> Print

for ty::ShimKind<'tcx> { ty::ShimKind::DropGlue(_, None) => cx.write_str("shim(None)"), ty::ShimKind::DropGlue(_, Some(ty)) => cx.write_str(&format!("shim(Some({ty}))")), ty::ShimKind::Clone(_, ty) => cx.write_str(&format!("shim({ty})")), - ty::ShimKind::FnPtrAsPtr(_, ty) => cx.write_str(&format!("shim({ty})")), + ty::ShimKind::FnAddrAsPtr(_, ty) => cx.write_str(&format!("shim({ty})")), ty::ShimKind::FnPtrFromPtr(_, ty) => cx.write_str(&format!("shim({ty})")), ty::ShimKind::FutureDropPoll(_, proxy_ty, impl_ty) => { cx.write_str(&format!("dropshim({proxy_ty}-{impl_ty})")) diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs index 555d4978f0899..9666120a3ee3a 100644 --- a/compiler/rustc_middle/src/ty/print/pretty.rs +++ b/compiler/rustc_middle/src/ty/print/pretty.rs @@ -3122,11 +3122,6 @@ impl<'tcx> ty::PolyTraitClause<'tcx> { } } -#[derive(Debug, Copy, Clone, Lift)] -pub struct PrintClosureAsImpl<'tcx> { - pub closure: ty::ClosureArgs>, -} - macro_rules! forward_display_to_print { ($($ty:ty),+) => { $( @@ -3411,10 +3406,6 @@ define_print_and_forward_display! { self.0.trait_ref.print_trait_sugared().print(p)?; } - PrintClosureAsImpl<'tcx> { - p.pretty_print_closure_as_impl(self.closure)?; - } - ty::ParamTy { write!(p, "{}", self.name)?; } diff --git a/compiler/rustc_mir_transform/src/inline.rs b/compiler/rustc_mir_transform/src/inline.rs index d836f433c13f9..c932d8c22c6e2 100644 --- a/compiler/rustc_mir_transform/src/inline.rs +++ b/compiler/rustc_mir_transform/src/inline.rs @@ -763,7 +763,7 @@ fn check_mir_is_available<'tcx, I: Inliner<'tcx>>( | InstanceKind::Shim(ShimKind::DropGlue(..)) | InstanceKind::Shim(ShimKind::Clone(..)) | InstanceKind::Shim(ShimKind::ThreadLocal(..)) - | InstanceKind::Shim(ShimKind::FnPtrAsPtr(..)) + | InstanceKind::Shim(ShimKind::FnAddrAsPtr(..)) | InstanceKind::Shim(ShimKind::FnPtrFromPtr(..)) => return Ok(()), } diff --git a/compiler/rustc_mir_transform/src/inline/cycle.rs b/compiler/rustc_mir_transform/src/inline/cycle.rs index ed3fcb1bbc679..77ddecabc291f 100644 --- a/compiler/rustc_mir_transform/src/inline/cycle.rs +++ b/compiler/rustc_mir_transform/src/inline/cycle.rs @@ -36,7 +36,7 @@ fn should_recurse<'tcx>(tcx: TyCtxt<'tcx>, callee: ty::Instance<'tcx>) -> bool { | InstanceKind::Shim(ShimKind::Clone(..)) => {} // This shim does not call any other functions, thus there can be no recursion. - InstanceKind::Shim(ShimKind::FnPtrAsPtr(..) | ShimKind::FnPtrFromPtr(..)) => return false, + InstanceKind::Shim(ShimKind::FnAddrAsPtr(..) | ShimKind::FnPtrFromPtr(..)) => return false, // FIXME: A not fully instantiated drop shim can cause ICEs if one attempts to // have its MIR built. Likely oli-obk just screwed up the `ParamEnv`s, so this diff --git a/compiler/rustc_mir_transform/src/shim.rs b/compiler/rustc_mir_transform/src/shim.rs index abe3490fb7886..437eb0e394f11 100644 --- a/compiler/rustc_mir_transform/src/shim.rs +++ b/compiler/rustc_mir_transform/src/shim.rs @@ -126,7 +126,7 @@ fn make_shim<'tcx>(tcx: TyCtxt<'tcx>, shim: ty::ShimKind<'tcx>) -> Body<'tcx> { } ty::ShimKind::ThreadLocal(..) => build_thread_local_shim(tcx, shim), ty::ShimKind::Clone(def_id, ty) => build_clone_shim(tcx, def_id, ty), - ty::ShimKind::FnPtrAsPtr(def_id, ty) => build_fn_ptr_as_ptr_shim(tcx, def_id, ty), + ty::ShimKind::FnAddrAsPtr(def_id, ty) => build_fn_addr_as_ptr_shim(tcx, def_id, ty), ty::ShimKind::FnPtrFromPtr(def_id, ty) => build_fn_ptr_from_ptr_shim(tcx, def_id, ty), ty::ShimKind::FutureDropPoll(def_id, proxy_ty, impl_ty) => { let mut body = @@ -1095,12 +1095,16 @@ pub(super) fn build_adt_ctor(tcx: TyCtxt<'_>, ctor_id: DefId) -> Body<'_> { /// } /// } /// ``` -fn build_fn_ptr_as_ptr_shim<'tcx>( +fn build_fn_addr_as_ptr_shim<'tcx>( tcx: TyCtxt<'tcx>, def_id: DefId, self_ty: Ty<'tcx>, ) -> Body<'tcx> { - assert_matches!(self_ty.kind(), ty::FnPtr(..), "expected fn ptr, found {self_ty}"); + assert_matches!( + self_ty.kind(), + ty::FnPtr(..) | ty::FnDef(..), + "expected fn ptr or function def, found {self_ty}" + ); let span = tcx.def_span(def_id); let nonnull_did = tcx.require_lang_item(LangItem::NonNull, span); @@ -1116,7 +1120,7 @@ fn build_fn_ptr_as_ptr_shim<'tcx>( let Some(sig) = tcx.fn_sig(def_id).instantiate(tcx, &[self_ty.into()]).skip_norm_wip().no_bound_vars() else { - span_bug!(span, "FnPtr::as_ptr with bound vars for `{self_ty}`"); + span_bug!(span, "FnAddr::as_ptr with bound vars for `{self_ty}`"); }; let mut locals = local_decls_for_sig(&sig, span); @@ -1126,8 +1130,36 @@ fn build_fn_ptr_as_ptr_shim<'tcx>( // FIXME: use `expose_provenance` once we figure out whether function pointers have meaningful // provenance. let raw_unit_ptr = Ty::new_imm_ptr(tcx, tcx.types.unit); - let cast_to_raw_rvalue = - Rvalue::Cast(CastKind::FnPtrToPtr, Operand::Move(Place::from(Local::arg(0))), raw_unit_ptr); + + let fn_ptr_operand = match self_ty.kind() { + ty::FnDef(..) => { + let fn_sig = self_ty.fn_sig(tcx); + let fn_ptr_ty = Ty::new_fn_ptr(tcx, fn_sig); + let fn_ptr = + Place::from(locals.push(LocalDecl::with_source_info(fn_ptr_ty, source_info))); + + statements.push(Statement::new( + source_info, + StatementKind::Assign(Box::new(( + fn_ptr, + Rvalue::Cast( + CastKind::PointerCoercion( + ty::adjustment::PointerCoercion::ReifyFnPointer(fn_sig.safety()), + CoercionSource::Implicit, + ), + Operand::Move(Place::from(Local::arg(0))), + fn_ptr_ty, + ), + ))), + )); + + Operand::Move(fn_ptr) + } + _ => Operand::Move(Place::from(Local::arg(0))), + }; + + let cast_to_raw_rvalue = Rvalue::Cast(CastKind::FnPtrToPtr, fn_ptr_operand, raw_unit_ptr); + let raw_ptr = locals.push(LocalDecl::with_source_info(raw_unit_ptr, source_info)).into(); statements.push(Statement::new( source_info, @@ -1146,7 +1178,7 @@ fn build_fn_ptr_as_ptr_shim<'tcx>( Terminator { source_info, kind: TerminatorKind::Return }, false, ); - let source = MirSource::from_shim(ty::ShimKind::FnPtrAsPtr(def_id, self_ty)); + let source = MirSource::from_shim(ty::ShimKind::FnAddrAsPtr(def_id, self_ty)); new_body(source, IndexVec::from_elem_n(start_block, 1), locals, sig.inputs().len(), span) } diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs index f4bdb1e785205..9833b6fafdaf8 100644 --- a/compiler/rustc_monomorphize/src/collector.rs +++ b/compiler/rustc_monomorphize/src/collector.rs @@ -1065,7 +1065,7 @@ fn visit_instance_use<'tcx>( | ty::InstanceKind::Shim(ty::ShimKind::ConstructCoroutineInClosure { .. }) | ty::InstanceKind::Shim(ty::ShimKind::FnPtr(..)) | ty::InstanceKind::Shim(ty::ShimKind::Clone(..)) - | ty::InstanceKind::Shim(ty::ShimKind::FnPtrAsPtr(..)) + | ty::InstanceKind::Shim(ty::ShimKind::FnAddrAsPtr(..)) | ty::InstanceKind::Shim(ty::ShimKind::FnPtrFromPtr(..)) => { output.push(create_fn_mono_item(tcx, instance, source)); } diff --git a/compiler/rustc_monomorphize/src/partitioning.rs b/compiler/rustc_monomorphize/src/partitioning.rs index 16df895b0f728..a6bcfbd94a35d 100644 --- a/compiler/rustc_monomorphize/src/partitioning.rs +++ b/compiler/rustc_monomorphize/src/partitioning.rs @@ -654,7 +654,7 @@ fn characteristic_def_id_of_mono_item<'tcx>( | ty::InstanceKind::Shim(ty::ShimKind::DropGlue(..)) | ty::InstanceKind::Shim(ty::ShimKind::Clone(..)) | ty::InstanceKind::Shim(ty::ShimKind::ThreadLocal(..)) - | ty::InstanceKind::Shim(ty::ShimKind::FnPtrAsPtr(..)) + | ty::InstanceKind::Shim(ty::ShimKind::FnAddrAsPtr(..)) | ty::InstanceKind::Shim(ty::ShimKind::FnPtrFromPtr(..)) | ty::InstanceKind::Shim(ty::ShimKind::FutureDropPoll(..)) | ty::InstanceKind::Shim(ty::ShimKind::AsyncDropGlue(..)) @@ -841,7 +841,7 @@ fn mono_item_visibility<'tcx>( | InstanceKind::Shim(ShimKind::ConstructCoroutineInClosure { .. }) | InstanceKind::Shim(ShimKind::DropGlue(..)) | InstanceKind::Shim(ShimKind::Clone(..)) - | InstanceKind::Shim(ShimKind::FnPtrAsPtr(..)) + | InstanceKind::Shim(ShimKind::FnAddrAsPtr(..)) | InstanceKind::Shim(ShimKind::FnPtrFromPtr(..)) => return Visibility::Hidden, }; diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs index 13c297c836002..ed34da0477c05 100644 --- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs +++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs @@ -314,6 +314,12 @@ where goal: Goal, ) -> Result, NoSolutionOrRerunNonErased>; + /// A type is a `FnStatic` if it is of `FnDef` type. + fn consider_builtin_fn_static_trait_candidate( + ecx: &mut EvalCtxt<'_, D>, + goal: Goal, + ) -> Result, NoSolutionOrRerunNonErased>; + /// A callable type (a closure, fn def, or fn ptr) is known to implement the `Fn` /// family of traits where `A` is given by the signature of the type. fn consider_builtin_fn_trait_candidates( @@ -680,6 +686,13 @@ where Some(SolverTraitLangItem::FnPtrTrait) => { G::consider_builtin_fn_ptr_trait_candidate(self, goal) } + Some(SolverTraitLangItem::FnAddrTrait) => { + if matches!(goal.predicate.self_ty().kind(), ty::FnDef(..)) { + G::consider_builtin_fn_static_trait_candidate(self, goal) + } else { + G::consider_builtin_fn_ptr_trait_candidate(self, goal) + } + } Some(SolverTraitLangItem::AsyncFnKindHelper) => { G::consider_builtin_async_fn_kind_helper_candidate(self, goal) } diff --git a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs index 44832635b8908..a20c17ce6933f 100644 --- a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs +++ b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs @@ -293,6 +293,13 @@ where unimplemented!("Fn* are not yet const") } + fn consider_builtin_fn_static_trait_candidate( + _ecx: &mut EvalCtxt<'_, D>, + _goal: Goal, + ) -> Result, NoSolutionOrRerunNonErased> { + unimplemented!("Fn* are not yet const") + } + #[instrument(level = "trace", skip_all, ret)] fn consider_builtin_fn_trait_candidates( ecx: &mut EvalCtxt<'_, D>, diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs index 9c32cf73f39a8..d382590dd31ed 100644 --- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs +++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs @@ -1,8 +1,6 @@ use std::mem; use std::ops::ControlFlow; -#[cfg(feature = "nightly")] -use rustc_macros::StableHash; use rustc_type_ir::data_structures::HashSet; use rustc_type_ir::inherent::*; use rustc_type_ir::region_constraint::RegionConstraint; @@ -168,13 +166,6 @@ where pub(super) inspect: inspect::EvaluationStepBuilder, } -#[derive(PartialEq, Eq, Debug, Hash, Clone, Copy)] -#[cfg_attr(feature = "nightly", derive(StableHash))] -pub enum GenerateProofTree { - Yes, - No, -} - pub trait SolverDelegateEvalExt: SolverDelegate { /// Evaluates a goal from **outside** of the trait solver. /// diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs index d46d40a0ec31a..5e449db8d8a94 100644 --- a/compiler/rustc_next_trait_solver/src/solve/mod.rs +++ b/compiler/rustc_next_trait_solver/src/solve/mod.rs @@ -30,8 +30,7 @@ use thin_vec::{ThinVec, thin_vec}; use tracing::instrument; pub use self::eval_ctxt::{ - EvalCtxt, GenerateProofTree, SolverDelegateEvalExt, - evaluate_root_goal_for_proof_tree_raw_provider, fast_path, + EvalCtxt, SolverDelegateEvalExt, evaluate_root_goal_for_proof_tree_raw_provider, fast_path, }; use crate::delegate::SolverDelegate; use crate::solve::assembly::Candidate; diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to.rs index 873c44b402315..da6f57f044d5a 100644 --- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to.rs +++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to.rs @@ -531,6 +531,13 @@ where panic!("`FnPtr` does not have an associated type: {:?}", goal); } + fn consider_builtin_fn_static_trait_candidate( + _ecx: &mut EvalCtxt<'_, D>, + goal: Goal, + ) -> Result, NoSolutionOrRerunNonErased> { + panic!("`FnStatic` does not have an associated type: {:?}", goal); + } + fn consider_builtin_fn_trait_candidates( ecx: &mut EvalCtxt<'_, D>, goal: Goal, diff --git a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs index 6b40996eb6d65..1157523585c5e 100644 --- a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs +++ b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs @@ -368,6 +368,33 @@ where } } + fn consider_builtin_fn_static_trait_candidate( + ecx: &mut EvalCtxt<'_, D>, + goal: Goal, + ) -> Result, NoSolutionOrRerunNonErased> { + let self_ty = goal.predicate.self_ty(); + match goal.predicate.polarity { + // impl FnStatic for FnDef {} + ty::ClausePolarity::Positive => match self_ty.kind() { + ty::FnDef(_, _) => { + ecx.probe_builtin_trait_candidate(BuiltinImplSource::Misc).enter(|ecx| { + ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes) + }) + } + _ => Err(NoSolution.into()), + }, + // impl !FnStatic for T where T != FnDef && T is rigid {} + ty::ClausePolarity::Negative => match self_ty.kind() { + ty::FnDef(_, _) if self_ty.is_known_rigid() => { + ecx.probe_builtin_trait_candidate(BuiltinImplSource::Misc).enter(|ecx| { + ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes) + }) + } + _ => Err(NoSolution.into()), + }, + } + } + fn consider_builtin_fn_trait_candidates( ecx: &mut EvalCtxt<'_, D>, goal: Goal, diff --git a/compiler/rustc_parse/src/lib.rs b/compiler/rustc_parse/src/lib.rs index 2c79db50a73ef..217e566057622 100644 --- a/compiler/rustc_parse/src/lib.rs +++ b/compiler/rustc_parse/src/lib.rs @@ -1,7 +1,6 @@ //! The main parser interface. // tidy-alphabetical-start -#![cfg_attr(bootstrap, feature(debug_closure_helpers))] #![cfg_attr(test, feature(iter_order_by))] #![feature(default_field_values)] #![feature(deref_patterns)] diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs index a89fd9b6298f3..10f4d73e3e4cd 100644 --- a/compiler/rustc_parse/src/parser/mod.rs +++ b/compiler/rustc_parse/src/parser/mod.rs @@ -1101,7 +1101,7 @@ impl<'a> Parser<'a> { /// Parses a comma-separated sequence, including both delimiters. /// The function `f` must consume tokens until reaching the next separator or /// closing bracket. - pub fn parse_delim_comma_seq( + fn parse_delim_comma_seq( &mut self, open: ExpTokenPair, close: ExpTokenPair, @@ -1351,7 +1351,7 @@ impl<'a> Parser<'a> { /// ```enbf /// FieldName = IntLit | Ident /// ``` - pub fn parse_field_name(&mut self) -> PResult<'a, Ident> { + fn parse_field_name(&mut self) -> PResult<'a, Ident> { if let token::Literal(token::Lit { kind: token::Integer, symbol, suffix }) = self.token.kind { if let Some(suffix) = suffix { diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs index b66d7310dbea5..f09faad96e16a 100644 --- a/compiler/rustc_parse/src/parser/ty.rs +++ b/compiler/rustc_parse/src/parser/ty.rs @@ -4,7 +4,7 @@ use rustc_ast::{ self as ast, BoundAsyncness, BoundConstness, BoundPolarity, DUMMY_NODE_ID, FnPtrTy, FnRetTy, GenericBound, GenericBounds, GenericParam, Generics, Lifetime, MacCall, Mutability, Path, Pinnedness, PolyTraitRef, PreciseCapturingArg, TraitBoundModifiers, TraitObjectSyntax, Ty, - TyKind, UnsafeBinderTy, + TyKind, TyPatKind, UnsafeBinderTy, }; use rustc_errors::{Applicability, Diag, E0516, PResult}; use rustc_span::{ErrorGuaranteed, Ident, Span, kw, sym}; @@ -423,6 +423,10 @@ impl<'a> Parser<'a> { self.parse_unsafe_binder_ty()? } else if self.eat_forced_keyword_noexpect(kw::FieldOf) { self.parse_ty_field_of(lo)? + } else if self.eat_forced_keyword_noexpect(kw::PatternType) { + self.parse_pat_ty(lo)? + } else if self.eat_forced_keyword_noexpect(kw::ViewType) { + self.parse_view_ty(lo)? } else { let msg = format!("expected type, found {}", super::token_descr(&self.token)); let mut err = self.dcx().struct_span_err(lo, msg); @@ -826,7 +830,7 @@ impl<'a> Parser<'a> { Ok(TyKind::Err(guar)) } - pub(crate) fn parse_ty_field_of(&mut self, lo: Span) -> PResult<'a, TyKind> { + fn parse_ty_field_of(&mut self, lo: Span) -> PResult<'a, TyKind> { self.expect(exp!(OpenParen))?; let container = self.parse_ty()?; @@ -871,6 +875,69 @@ impl<'a> Parser<'a> { } } + fn parse_pat_ty(&mut self, lo: Span) -> PResult<'a, TyKind> { + self.expect(exp!(OpenParen))?; + + let ty = self.parse_ty()?; + self.expect_keyword(exp!(Is))?; + + let pat = if self.eat(exp!(Bang)) { + let lo = self.prev_token.span; + self.expect_keyword(exp!(Null))?; + Self::mk_ty_pat(TyPatKind::NotNull, lo.to(self.token.span)) + } else { + let pat = self.parse_pat_no_top_guard( + None, + super::RecoverComma::No, + super::RecoverColon::No, + super::CommaRecoveryMode::EitherTupleOrPipe, + )?; + self.pat_to_ty_pat(pat) + }; + + self.expect(exp!(CloseParen))?; + + self.psess.gated_spans.gate(sym::internal_syntax, lo.to(self.token.span)); + + Ok(TyKind::Pat(ty, Box::new(pat))) + } + + fn pat_to_ty_pat(&self, pat: ast::Pat) -> ast::TyPat { + let kind = match pat.kind { + ast::PatKind::Range(start, end, include_end) => TyPatKind::Range( + start.map(|value| Box::new(ast::AnonConst { id: DUMMY_NODE_ID, value })), + end.map(|value| Box::new(ast::AnonConst { id: DUMMY_NODE_ID, value })), + include_end, + ), + ast::PatKind::Or(variants) => { + TyPatKind::Or(variants.into_iter().map(|pat| self.pat_to_ty_pat(pat)).collect()) + } + ast::PatKind::Err(guar) => TyPatKind::Err(guar), + ast::PatKind::Paren(p) => self.pat_to_ty_pat(*p).kind, + _ => TyPatKind::Err( + self.dcx().span_err(pat.span, "pattern not supported in pattern types"), + ), + }; + Self::mk_ty_pat(kind, pat.span) + } + + fn mk_ty_pat(kind: TyPatKind, span: Span) -> ast::TyPat { + ast::TyPat { id: DUMMY_NODE_ID, kind, span } + } + + fn parse_view_ty(&mut self, lo: Span) -> PResult<'a, ast::TyKind> { + self.expect(exp!(OpenParen))?; + let ty = self.parse_ty()?; + self.expect(exp!(Dot))?; + let (fields, _) = self + .parse_delim_comma_seq(exp!(OpenBrace), exp!(CloseBrace), |p| p.parse_field_name())?; + self.expect(exp!(CloseParen))?; + + self.psess.gated_spans.gate(sym::internal_syntax, lo.to(self.prev_token.span)); + + Ok(ast::TyKind::View(ty, fields)) + } + /// Parses a function pointer type (`TyKind::FnPtr`). /// ```ignore (illustrative) /// [unsafe] [extern "ABI"] fn (S) -> T diff --git a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs index e0c8dbd6a3d16..0d47a89b2a002 100644 --- a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs +++ b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs @@ -657,11 +657,11 @@ pub(crate) fn transform_instance<'tcx>( // (i.e., type ids are encoded for them as is). ty::InstanceKind::Shim(ty::ShimKind::Clone(..)) => instance, - // FnPtrAsPtrShims and FnPtrFromPtrShims (i.e., compiler-generated `::as_ptr` + // FnAddrAsPtrShims and FnPtrFromPtrShims (i.e., compiler-generated `::as_ptr` // and `::from_ptr` implementations): the FnPtr trait is not dyn compatible, so // they can not be called through a vtable and are not transformed (i.e., type ids are // encoded for them as is). - ty::InstanceKind::Shim(ty::ShimKind::FnPtrAsPtr(..) | ty::ShimKind::FnPtrFromPtr(..)) => { + ty::InstanceKind::Shim(ty::ShimKind::FnAddrAsPtr(..) | ty::ShimKind::FnPtrFromPtr(..)) => { instance } diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs index 44fbbbaccd66f..03dc07870345a 100644 --- a/compiler/rustc_span/src/lib.rs +++ b/compiler/rustc_span/src/lib.rs @@ -17,7 +17,6 @@ // tidy-alphabetical-start #![allow(internal_features)] -#![cfg_attr(all(bootstrap, target_arch = "loongarch64"), feature(stdarch_loongarch))] #![feature(core_io_borrowed_buf)] #![feature(decl_macro)] #![feature(diagnostic_on_unknown)] diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index 650aa6d3205da..ea360c953afe8 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -133,6 +133,7 @@ symbols! { FieldOf: "field_of", MacroRules: "macro_rules", OffsetOf: "offset_of", + PatternType: "pattern_type", Pin: "pin", Raw: "raw", Reuse: "reuse", @@ -140,6 +141,7 @@ symbols! { TypeAscribe: "type_ascribe", Union: "union", UnwrapBinder: "unwrap_binder", + ViewType: "view_type", WrapBinder: "wrap_binder", Yeet: "yeet", // tidy-alphabetical-end @@ -1018,6 +1020,9 @@ symbols! { fmul_algebraic, fmul_fast, fmuladd, + fn_addr_addr_fn, + fn_addr_as_ptr, + fn_addr_trait, fn_align, fn_body, fn_delegation, @@ -1025,7 +1030,6 @@ symbols! { fn_mut, fn_once, fn_once_output, - fn_ptr_as_ptr, fn_ptr_from_ptr, fn_ptr_trait, fn_static, @@ -1609,7 +1613,6 @@ symbols! { path, pattern_complexity_limit, pattern_parentheses, - pattern_type, pattern_type_range_trait, pattern_types, phantom_data, @@ -2390,7 +2393,6 @@ symbols! { vgpr384, vgpr512, vgpr1024, - view_type, view_types, vis, visible_private_types, @@ -3003,19 +3005,9 @@ pub mod kw { /// /// Given that `sym` is imported, use them like `sym::symbol_name`. /// For example `sym::rustfmt` or `sym::u8`. -#[cfg_attr( - bootstrap, - diagnostic::on_unknown( - label = "`{Unresolved}` is not a pre-interned symbol", - note = "consider adding `{Unresolved}` to the `symbols!` invocation in compiler/rustc_span/src/symbol.rs" - ) -)] -#[cfg_attr( - not(bootstrap), - diagnostic::on_unknown( - label = "`{unresolved}` is not a pre-interned symbol", - note = "consider adding `{unresolved}` to the `symbols!` invocation in compiler/rustc_span/src/symbol.rs" - ) +#[diagnostic::on_unknown( + label = "`{unresolved}` is not a pre-interned symbol", + note = "consider adding `{unresolved}` to the `symbols!` invocation in compiler/rustc_span/src/symbol.rs" )] pub mod sym { use super::Symbol; diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs index 925ff06c4131c..a9362d4c90908 100644 --- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs +++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs @@ -126,6 +126,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { Some(LangItem::FnPtrTrait) => { self.assemble_candidates_for_fn_ptr_trait(obligation, &mut candidates); } + Some(LangItem::FnAddrTrait) => { + self.assemble_candidates_for_fn_ptr_trait(obligation, &mut candidates); + self.assemble_candidates_for_fn_static_trait(obligation, &mut candidates); + } Some(LangItem::BikeshedGuaranteedNoDrop) => { self.assemble_candidates_for_bikeshed_guaranteed_no_drop_trait( obligation, @@ -1416,6 +1420,22 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } } + fn assemble_candidates_for_fn_static_trait( + &mut self, + obligation: &PolyTraitObligation<'tcx>, + candidates: &mut SelectionCandidateSet<'tcx>, + ) { + let self_ty = self.infcx.deeply_resolve_ignoring_regions(obligation.self_ty()); + + match *self_ty.skip_binder().kind() { + ty::FnDef(_, _) => candidates.vec.push(BuiltinCandidate), + ty::Infer(ty::InferTy::TyVar(_) | ty::InferTy::FreshTy(_)) => { + candidates.ambiguous = true; + } + _ => {} + } + } + fn assemble_candidates_for_bikeshed_guaranteed_no_drop_trait( &mut self, obligation: &PolyTraitObligation<'tcx>, diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs index 88bb711844cb1..1d0696d745373 100644 --- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs +++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs @@ -261,6 +261,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { | LangItem::DiscriminantKind | LangItem::Field | LangItem::FnPtrTrait + | LangItem::FnAddrTrait | LangItem::PointeeTrait | LangItem::Tuple | LangItem::Unpin, diff --git a/compiler/rustc_ty_utils/src/instance.rs b/compiler/rustc_ty_utils/src/instance.rs index 2bdffe20f5bcd..4751449832ca1 100644 --- a/compiler/rustc_ty_utils/src/instance.rs +++ b/compiler/rustc_ty_utils/src/instance.rs @@ -300,24 +300,34 @@ fn resolve_associated_item<'tcx>( if !matches!(self_ty.kind(), ty::FnPtr(..)) { return Ok(None); } - if tcx.is_lang_item(trait_item_id, LangItem::FnPtrAsPtr) { - Some(Instance { - def: ty::InstanceKind::Shim(ty::ShimKind::FnPtrAsPtr( + match tcx.as_lang_item(trait_item_id) { + Some(LangItem::FnPtrFromPtr) => Some(Instance { + def: ty::InstanceKind::Shim(ty::ShimKind::FnPtrFromPtr( trait_item_id, self_ty, )), args: rcvr_args, - }) - } else if tcx.is_lang_item(trait_item_id, LangItem::FnPtrFromPtr) { - Some(Instance { - def: ty::InstanceKind::Shim(ty::ShimKind::FnPtrFromPtr( + }), + _ => bug!("Unknown item for FnPtr: {:?}", trait_item_id), + } + } else if tcx.is_lang_item(trait_ref.def_id, LangItem::FnAddrTrait) { + let self_ty = trait_ref.self_ty(); + if !matches!(self_ty.kind(), ty::FnPtr(..) | ty::FnDef(..)) { + return Ok(None); + } + match tcx.as_lang_item(trait_item_id) { + Some(LangItem::FnAddrAsPtr) => Some(Instance { + def: ty::InstanceKind::Shim(ty::ShimKind::FnAddrAsPtr( trait_item_id, self_ty, )), args: rcvr_args, - }) - } else { - Some(Instance { def: ty::InstanceKind::Item(trait_item_id), args: rcvr_args }) + }), + Some(LangItem::FnAddrAddrFn) => Some(Instance { + def: ty::InstanceKind::Item(trait_item_id), + args: rcvr_args, + }), + _ => bug!("Unknown item for FnAddr: {:?}", trait_item_id), } } else if let Some(target_kind) = tcx.fn_trait_kind_from_def_id(trait_ref.def_id) { // FIXME: This doesn't check for malformed libcore that defines, e.g., diff --git a/compiler/rustc_type_ir/src/lang_items.rs b/compiler/rustc_type_ir/src/lang_items.rs index fb6f6ba0fbb19..6dccb5e4b775d 100644 --- a/compiler/rustc_type_ir/src/lang_items.rs +++ b/compiler/rustc_type_ir/src/lang_items.rs @@ -43,6 +43,7 @@ pub enum SolverTraitLangItem { Drop, Field, Fn, + FnAddrTrait, FnMut, FnOnce, FnPtrTrait, diff --git a/compiler/rustc_type_ir/src/lib.rs b/compiler/rustc_type_ir/src/lib.rs index 2333fa9cbac1d..ef258e3b18321 100644 --- a/compiler/rustc_type_ir/src/lib.rs +++ b/compiler/rustc_type_ir/src/lib.rs @@ -27,12 +27,7 @@ #![allow(rustc::usage_of_type_ir_traits)] #![cfg_attr(feature = "nightly", allow(internal_features))] #![cfg_attr(feature = "nightly", feature(associated_type_defaults, rustc_attrs, negative_impls))] -// NOTE: the outer `cfg_attr` is only there so that r-a doesn't see the nightly-only `bootstrap` -// in the inner `cfg_attr`. When the latter is removed, the former can be removed as well. -#![cfg_attr( - feature = "nightly", - cfg_attr(not(bootstrap), deny(rustc::missing_generic_type_visitable_derive)) -)] +#![deny(rustc::missing_generic_type_visitable_derive)] // tidy-alphabetical-end extern crate self as rustc_type_ir; diff --git a/library/alloc/src/collections/binary_heap/mod.rs b/library/alloc/src/collections/binary_heap/mod.rs index b0e9e5203edfb..1d7e6ad89a469 100644 --- a/library/alloc/src/collections/binary_heap/mod.rs +++ b/library/alloc/src/collections/binary_heap/mod.rs @@ -1441,7 +1441,7 @@ impl BinaryHeap { #[must_use] #[stable(feature = "rust1", since = "1.0.0")] #[rustc_confusables("length", "size")] - #[rustc_const_stable(feature = "const_binary_heap_len", since = "CURRENT_RUSTC_VERSION")] + #[rustc_const_stable(feature = "const_binary_heap_len", since = "1.101.0")] pub const fn len(&self) -> usize { self.data.len() } @@ -1466,7 +1466,7 @@ impl BinaryHeap { /// ``` #[must_use] #[stable(feature = "rust1", since = "1.0.0")] - #[rustc_const_stable(feature = "const_binary_heap_len", since = "CURRENT_RUSTC_VERSION")] + #[rustc_const_stable(feature = "const_binary_heap_len", since = "1.101.0")] pub const fn is_empty(&self) -> bool { self.len() == 0 } diff --git a/library/alloc/src/collections/btree/map.rs b/library/alloc/src/collections/btree/map.rs index c4d9bfe777b16..17198946a3cde 100644 --- a/library/alloc/src/collections/btree/map.rs +++ b/library/alloc/src/collections/btree/map.rs @@ -2837,7 +2837,7 @@ impl BTreeMap { /// ``` #[must_use] #[stable(feature = "rust1", since = "1.0.0")] - #[rustc_const_stable(feature = "const_btree_len", since = "CURRENT_RUSTC_VERSION")] + #[rustc_const_stable(feature = "const_btree_len", since = "1.101.0")] #[rustc_confusables("length", "size")] pub const fn len(&self) -> usize { self.length @@ -2857,7 +2857,7 @@ impl BTreeMap { /// ``` #[must_use] #[stable(feature = "rust1", since = "1.0.0")] - #[rustc_const_stable(feature = "const_btree_len", since = "CURRENT_RUSTC_VERSION")] + #[rustc_const_stable(feature = "const_btree_len", since = "1.101.0")] pub const fn is_empty(&self) -> bool { self.len() == 0 } diff --git a/library/alloc/src/collections/btree/set.rs b/library/alloc/src/collections/btree/set.rs index 6008bcb4389ac..c74d1a12bf081 100644 --- a/library/alloc/src/collections/btree/set.rs +++ b/library/alloc/src/collections/btree/set.rs @@ -1266,7 +1266,7 @@ impl BTreeSet { /// ``` #[must_use] #[stable(feature = "rust1", since = "1.0.0")] - #[rustc_const_stable(feature = "const_btree_len", since = "CURRENT_RUSTC_VERSION")] + #[rustc_const_stable(feature = "const_btree_len", since = "1.101.0")] #[rustc_confusables("length", "size")] pub const fn len(&self) -> usize { self.map.len() @@ -1286,7 +1286,7 @@ impl BTreeSet { /// ``` #[must_use] #[stable(feature = "rust1", since = "1.0.0")] - #[rustc_const_stable(feature = "const_btree_len", since = "CURRENT_RUSTC_VERSION")] + #[rustc_const_stable(feature = "const_btree_len", since = "1.101.0")] pub const fn is_empty(&self) -> bool { self.len() == 0 } diff --git a/library/alloc/src/collections/linked_list.rs b/library/alloc/src/collections/linked_list.rs index 38c1e770e6981..07d7a62a03b24 100644 --- a/library/alloc/src/collections/linked_list.rs +++ b/library/alloc/src/collections/linked_list.rs @@ -689,7 +689,7 @@ impl LinkedList { #[inline] #[must_use] #[stable(feature = "rust1", since = "1.0.0")] - #[rustc_const_stable(feature = "const_linked_list_len", since = "CURRENT_RUSTC_VERSION")] + #[rustc_const_stable(feature = "const_linked_list_len", since = "1.101.0")] pub const fn is_empty(&self) -> bool { self.head.is_none() } @@ -717,7 +717,7 @@ impl LinkedList { #[inline] #[must_use] #[stable(feature = "rust1", since = "1.0.0")] - #[rustc_const_stable(feature = "const_linked_list_len", since = "CURRENT_RUSTC_VERSION")] + #[rustc_const_stable(feature = "const_linked_list_len", since = "1.101.0")] #[rustc_confusables("length", "size")] pub const fn len(&self) -> usize { self.len diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs index 51f5bc189281b..21b39d6a04615 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -1804,7 +1804,7 @@ impl VecDeque { /// assert_eq!(deque.len(), 1); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - #[rustc_const_stable(feature = "const_vec_deque_len", since = "CURRENT_RUSTC_VERSION")] + #[rustc_const_stable(feature = "const_vec_deque_len", since = "1.101.0")] #[rustc_confusables("length", "size")] pub const fn len(&self) -> usize { self.len @@ -1823,7 +1823,7 @@ impl VecDeque { /// assert!(!deque.is_empty()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - #[rustc_const_stable(feature = "const_vec_deque_len", since = "CURRENT_RUSTC_VERSION")] + #[rustc_const_stable(feature = "const_vec_deque_len", since = "1.101.0")] pub const fn is_empty(&self) -> bool { self.len == 0 } diff --git a/library/alloc/src/rcs/arc.rs b/library/alloc/src/rcs/arc.rs index 59048f9785263..b76001e55ae65 100644 --- a/library/alloc/src/rcs/arc.rs +++ b/library/alloc/src/rcs/arc.rs @@ -2925,7 +2925,7 @@ impl Arc { /// /// [`get_mut_unchecked`]: Self::get_mut_unchecked #[inline] - #[stable(feature = "arc_is_unique", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "arc_is_unique", since = "1.101.0")] pub fn is_unique(this: &Self) -> bool { // lock the weak pointer count if we appear to be the sole weak pointer // holder. diff --git a/library/alloc/src/rcs/rc.rs b/library/alloc/src/rcs/rc.rs index bdf965ed076f0..1874441f3f920 100644 --- a/library/alloc/src/rcs/rc.rs +++ b/library/alloc/src/rcs/rc.rs @@ -2045,7 +2045,7 @@ impl Rc { /// /// [`get_mut_unchecked`]: Self::get_mut_unchecked #[inline] - #[stable(feature = "arc_is_unique", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "arc_is_unique", since = "1.101.0")] pub fn is_unique(this: &Self) -> bool { Rc::weak_count(this) == 0 && Rc::strong_count(this) == 1 } diff --git a/library/alloc/src/string.rs b/library/alloc/src/string.rs index 97aa0ae1b45f0..c8336c4f43823 100644 --- a/library/alloc/src/string.rs +++ b/library/alloc/src/string.rs @@ -2107,7 +2107,7 @@ impl String { /// [`char`]: prim@char #[inline] #[must_use = "`self` will be dropped if the result is not used"] - #[stable(feature = "string_into_chars", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "string_into_chars", since = "1.101.0")] pub fn into_chars(self) -> IntoChars { IntoChars { bytes: self.into_bytes().into_iter() } } @@ -3619,12 +3619,12 @@ impl fmt::Write for String { /// [`into_chars`]: String::into_chars #[cfg_attr(not(no_global_oom_handling), derive(Clone))] #[must_use = "iterators are lazy and do nothing unless consumed"] -#[stable(feature = "string_into_chars", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "string_into_chars", since = "1.101.0")] pub struct IntoChars { bytes: vec::IntoIter, } -#[stable(feature = "string_into_chars", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "string_into_chars", since = "1.101.0")] impl fmt::Debug for IntoChars { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple("IntoChars").field(&self.as_str()).finish() @@ -3646,7 +3646,7 @@ impl IntoChars { /// chars.next(); /// assert_eq!(chars.as_str(), ""); /// ``` - #[stable(feature = "string_into_chars", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "string_into_chars", since = "1.101.0")] #[must_use] #[inline] pub fn as_str(&self) -> &str { @@ -3667,7 +3667,7 @@ impl IntoChars { /// assert_eq!(chars.into_string(), "ef"); /// ``` #[cfg(not(no_global_oom_handling))] - #[stable(feature = "string_into_chars", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "string_into_chars", since = "1.101.0")] #[inline] pub fn into_string(self) -> String { // SAFETY: `bytes` are kept in UTF-8 form, only removing whole `char`s at a time. @@ -3680,7 +3680,7 @@ impl IntoChars { } } -#[stable(feature = "string_into_chars", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "string_into_chars", since = "1.101.0")] impl Iterator for IntoChars { type Item = char; @@ -3714,7 +3714,7 @@ impl Iterator for IntoChars { } } -#[stable(feature = "string_into_chars", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "string_into_chars", since = "1.101.0")] impl DoubleEndedIterator for IntoChars { #[inline] fn next_back(&mut self) -> Option { @@ -3731,7 +3731,7 @@ impl DoubleEndedIterator for IntoChars { } } -#[stable(feature = "string_into_chars", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "string_into_chars", since = "1.101.0")] impl FusedIterator for IntoChars {} /// A draining iterator for `String`. diff --git a/library/alloc/src/vec/into_iter.rs b/library/alloc/src/vec/into_iter.rs index 982d499791d57..1534b6c6ed473 100644 --- a/library/alloc/src/vec/into_iter.rs +++ b/library/alloc/src/vec/into_iter.rs @@ -46,7 +46,7 @@ macro non_null { #[rustc_insignificant_dtor] pub struct IntoIter< T, - #[stable(feature = "vec_into_iter_allocator", since = "CURRENT_RUSTC_VERSION")] A: Allocator = Global, + #[stable(feature = "vec_into_iter_allocator", since = "1.101.0")] A: Allocator = Global, > { pub(super) buf: NonNull, pub(super) phantom: PhantomData, @@ -112,7 +112,7 @@ impl IntoIter { } /// Returns a reference to the underlying allocator. - #[stable(feature = "vec_into_iter_allocator", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "vec_into_iter_allocator", since = "1.101.0")] #[inline] pub fn allocator(&self) -> &A { &self.alloc diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index 99bdeea251bf4..05e459104361b 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -2351,7 +2351,7 @@ impl Vec { /// assert_eq!(v.try_remove(0), Some(1)); /// assert_eq!(v.try_remove(2), None); /// ``` - #[stable(feature = "vec_try_remove", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "vec_try_remove", since = "1.101.0")] #[rustc_confusables("delete", "take", "remove")] pub fn try_remove(&mut self, index: usize) -> Option { let len = self.len(); @@ -3836,32 +3836,24 @@ const fn dedup_simd_chunk_size() -> Option { if size == 8 { None } else { Some(SIMD_WIDTH) } } - all(target_arch = "aarch64", target_feature = "neon") => { + all(target_arch = "aarch64", target_feature = "neon") => Some(SIMD_WIDTH), + + all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "sse4.1") => { Some(SIMD_WIDTH) } - all( - any(target_arch = "x86", target_arch = "x86_64"), - target_feature = "sse4.1" - ) => Some(SIMD_WIDTH), - - all( - any(target_arch = "x86", target_arch = "x86_64"), - target_feature = "sse2" - ) => { + all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "sse2") => { // Packed 64-bit integer lane equality is only available on sse4.1 if size == 8 { None } else { Some(SIMD_WIDTH) } } - all( - any(target_arch = "riscv32", target_arch = "riscv64"), - target_feature = "v" - ) => Some(SIMD_WIDTH), + all(any(target_arch = "riscv32", target_arch = "riscv64"), target_feature = "v") => { + Some(SIMD_WIDTH) + } - all( - any(target_arch = "loongarch32", target_arch = "loongarch64"), - target_feature = "lsx" - ) => Some(SIMD_WIDTH), + all(any(target_arch = "loongarch32", target_arch = "loongarch64"), target_feature = "lsx") => { + Some(SIMD_WIDTH) + } _ => None, }; @@ -3951,7 +3943,7 @@ fn find_first_duplicate(v: &[T], chunk_size: usize) -> Option(elem: T, n: usize) -> Vec { vec![elem; n] } diff --git a/library/core/src/ffi/c_str.rs b/library/core/src/ffi/c_str.rs index 9ab47193cf174..89c0c4d4e217c 100644 --- a/library/core/src/ffi/c_str.rs +++ b/library/core/src/ffi/c_str.rs @@ -653,7 +653,7 @@ impl CStr { /// let cstr = c"Hello, world!"; /// println!("{}", cstr.display()); /// ``` - #[stable(feature = "cstr_display", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "cstr_display", since = "1.101.0")] #[must_use = "this does not display the `CStr`; \ it returns an object that can be displayed"] #[inline] @@ -874,19 +874,19 @@ impl FusedIterator for Bytes<'_> {} /// /// [`Display`]: fmt::Display /// [`format!`]: ../../../std/macro.format.html -#[stable(feature = "cstr_display", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "cstr_display", since = "1.101.0")] pub struct Display<'a> { c_str: &'a CStr, } -#[stable(feature = "cstr_display", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "cstr_display", since = "1.101.0")] impl fmt::Debug for Display<'_> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Debug::fmt(&self.c_str, f) } } -#[stable(feature = "cstr_display", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "cstr_display", since = "1.101.0")] impl fmt::Display for Display<'_> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(crate::byte_str::ByteStr::from_bytes(self.c_str.to_bytes()), f) diff --git a/library/core/src/ffi/va_list.rs b/library/core/src/ffi/va_list.rs index 74213005b566d..aed7adb6292ef 100644 --- a/library/core/src/ffi/va_list.rs +++ b/library/core/src/ffi/va_list.rs @@ -39,8 +39,12 @@ use crate::marker::PhantomCovariantLifetime; // derive `Copy`. However, in the future we might want to support a target where `va_copy` // allocates, or otherwise violates the requirements of `Copy`. Therefore `VaList` is only `Clone`. crate::cfg_select! { - all(target_arch = "aarch64", not(target_vendor = "apple"), not(target_os = "uefi"), not(windows)) => - { + all( + target_arch = "aarch64", + not(target_vendor = "apple"), + not(target_os = "uefi"), + not(windows) + ) => { /// AArch64 ABI implementation of a `va_list`. /// /// See the [AArch64 Procedure Call Standard] for more details. diff --git a/library/core/src/fmt/builders.rs b/library/core/src/fmt/builders.rs index 20ce752dd7c41..1b335a9426add 100644 --- a/library/core/src/fmt/builders.rs +++ b/library/core/src/fmt/builders.rs @@ -209,7 +209,7 @@ impl<'a, 'b: 'a> DebugStruct<'a, 'b> { /// r#"Bar { bar: 0x0000000a, another: "Hello World" }"#, /// ); /// ``` - #[stable(feature = "debug_closure_helpers", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "debug_closure_helpers", since = "1.101.0")] pub fn field_with( &mut self, name: &str, @@ -426,7 +426,7 @@ impl<'a, 'b: 'a> DebugTuple<'a, 'b> { /// r#"Foo(0x0000000a, "Hello World")"#, /// ); /// ``` - #[stable(feature = "debug_closure_helpers", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "debug_closure_helpers", since = "1.101.0")] pub fn field_with( &mut self, value_fmt: impl FnOnce(&mut fmt::Formatter<'_>) -> fmt::Result, @@ -652,7 +652,7 @@ impl<'a, 'b: 'a> DebugSet<'a, 'b> { /// "{[10, 11], {12, 13}}", /// ); /// ``` - #[stable(feature = "debug_closure_helpers", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "debug_closure_helpers", since = "1.101.0")] pub fn entry_with( &mut self, entry_fmt: impl FnOnce(&mut fmt::Formatter<'_>) -> fmt::Result, @@ -867,7 +867,7 @@ impl<'a, 'b: 'a> DebugList<'a, 'b> { /// "[[10, 11], {12, 13}]", /// ); /// ``` - #[stable(feature = "debug_closure_helpers", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "debug_closure_helpers", since = "1.101.0")] pub fn entry_with( &mut self, entry_fmt: impl FnOnce(&mut fmt::Formatter<'_>) -> fmt::Result, @@ -1158,7 +1158,7 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> { /// r#"{entry A: 0x0000000a, entry B: 0x0000000b}"#, /// ); /// ``` - #[stable(feature = "debug_closure_helpers", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "debug_closure_helpers", since = "1.101.0")] pub fn key_with( &mut self, key_fmt: impl FnOnce(&mut fmt::Formatter<'_>) -> fmt::Result, @@ -1256,7 +1256,7 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> { /// r#"{entry A: 0x0000000a, entry B: 0x0000000b}"#, /// ); /// ``` - #[stable(feature = "debug_closure_helpers", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "debug_closure_helpers", since = "1.101.0")] pub fn value_with( &mut self, value_fmt: impl FnOnce(&mut fmt::Formatter<'_>) -> fmt::Result, diff --git a/library/core/src/fmt/num_buffer.rs b/library/core/src/fmt/num_buffer.rs index 62089e30a06e2..ec135cf044749 100644 --- a/library/core/src/fmt/num_buffer.rs +++ b/library/core/src/fmt/num_buffer.rs @@ -85,7 +85,7 @@ impl NumBuffer { } } -#[stable(feature = "num_buffer_default", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "num_buffer_default", since = "1.101.0")] impl Default for NumBuffer { fn default() -> Self { Self::new() diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs index 822e62b5867ac..41f8749a9399b 100644 --- a/library/core/src/lib.rs +++ b/library/core/src/lib.rs @@ -98,7 +98,7 @@ #![feature(io_const_error)] #![feature(offset_of_enum)] #![feature(panic_internals)] -#![feature(pattern_type_macro)] +#![feature(pattern_types)] #![feature(ub_checks)] // tidy-alphabetical-end // @@ -146,7 +146,6 @@ #![feature(must_not_suspend)] #![feature(negative_impls)] #![feature(no_core)] -#![feature(pattern_types)] #![feature(pin_macro_internals)] #![feature(prelude_import)] #![feature(register_tool)] @@ -314,7 +313,7 @@ pub mod option; pub mod os; pub mod panic; pub mod panicking; -#[unstable(feature = "pattern_type_macro", issue = "123646")] +#[unstable(feature = "pattern_types", issue = "123646")] pub mod pat; pub mod pin; #[unstable(feature = "abort_immediate", issue = "154601")] @@ -351,7 +350,7 @@ mod bool; mod escape; mod tuple; mod unit; -#[unstable(feature = "view_type_macro", issue = "155938")] +#[unstable(feature = "view_types", issue = "155938")] pub mod view; #[stable(feature = "core_primitive", since = "1.43.0")] diff --git a/library/core/src/num/niche_types.rs b/library/core/src/num/niche_types.rs index 37037d8145fb0..6d3e59b05a2c3 100644 --- a/library/core/src/num/niche_types.rs +++ b/library/core/src/num/niche_types.rs @@ -5,9 +5,10 @@ )] use crate::cmp::Ordering; +use crate::fmt; use crate::hash::{Hash, Hasher}; use crate::marker::StructuralPartialEq; -use crate::{fmt, pattern_type}; +use crate::pat::pattern_type; macro_rules! define_valid_range_type { ($( diff --git a/library/core/src/num/nonzero.rs b/library/core/src/num/nonzero.rs index 99498252a127f..ac11846098087 100644 --- a/library/core/src/num/nonzero.rs +++ b/library/core/src/num/nonzero.rs @@ -305,7 +305,7 @@ where } } -#[stable(feature = "more_from_nonzero", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "more_from_nonzero", since = "1.101.0")] impl<'a, T> From<&'a NonZero> for &'a T where T: ZeroablePrimitive, @@ -318,7 +318,7 @@ where // FIXME: see library/std/tests/slice-from-array-issue-113238.rs /* -#[stable(feature = "more_from_nonzero", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "more_from_nonzero", since = "1.101.0")] impl<'a, T> From<&'a [NonZero]> for &'a [T] where T: ZeroablePrimitive, @@ -343,7 +343,7 @@ where } */ -#[stable(feature = "more_from_nonzero", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "more_from_nonzero", since = "1.101.0")] impl From<[NonZero; N]> for [T; N] where T: ZeroablePrimitive, @@ -358,7 +358,7 @@ where macro_rules! impl_ref_try_from { ($($t:ty),* $(,)?) => { $( - #[stable(feature = "more_from_nonzero", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "more_from_nonzero", since = "1.101.0")] impl<'a> TryFrom<&'a $t> for &'a NonZero<$t> { type Error = TryFromIntError; @@ -387,7 +387,7 @@ impl_ref_try_from! { char, } -#[stable(feature = "more_from_nonzero", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "more_from_nonzero", since = "1.101.0")] impl<'a, T> TryFrom<&'a [T]> for &'a [NonZero] where T: ZeroablePrimitive, @@ -400,7 +400,7 @@ where } } -#[stable(feature = "more_from_nonzero", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "more_from_nonzero", since = "1.101.0")] impl TryFrom<[T; N]> for [NonZero; N] where T: ZeroablePrimitive, diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs index 3ee925bd2e905..4f0da16dfca77 100644 --- a/library/core/src/num/uint_macros.rs +++ b/library/core/src/num/uint_macros.rs @@ -632,8 +632,8 @@ macro_rules! uint_impl { /// # } /// # #[cfg(not(overflow_checks))] panic!("fulfill should_panic"); /// ``` - #[rustc_const_stable(feature = "funnel_shifts", since = "CURRENT_RUSTC_VERSION")] - #[stable(feature = "funnel_shifts", since = "CURRENT_RUSTC_VERSION")] + #[rustc_const_stable(feature = "funnel_shifts", since = "1.101.0")] + #[stable(feature = "funnel_shifts", since = "1.101.0")] #[must_use = "this returns the result of the operation, without modifying the original"] #[inline(always)] #[rustc_inherit_overflow_checks] @@ -699,8 +699,8 @@ macro_rules! uint_impl { /// # } /// # #[cfg(not(overflow_checks))] panic!("fulfill should_panic"); /// ``` - #[rustc_const_stable(feature = "funnel_shifts", since = "CURRENT_RUSTC_VERSION")] - #[stable(feature = "funnel_shifts", since = "CURRENT_RUSTC_VERSION")] + #[rustc_const_stable(feature = "funnel_shifts", since = "1.101.0")] + #[stable(feature = "funnel_shifts", since = "1.101.0")] #[must_use = "this returns the result of the operation, without modifying the original"] #[inline(always)] #[rustc_inherit_overflow_checks] @@ -723,8 +723,8 @@ macro_rules! uint_impl { #[doc = concat!("`", stringify!($SelfT) , "::BITS`,")] /// i.e. when [`funnel_shl`](Self::funnel_shl) would panic. /// - #[rustc_const_stable(feature = "funnel_shifts", since = "CURRENT_RUSTC_VERSION")] - #[stable(feature = "funnel_shifts", since = "CURRENT_RUSTC_VERSION")] + #[rustc_const_stable(feature = "funnel_shifts", since = "1.101.0")] + #[stable(feature = "funnel_shifts", since = "1.101.0")] #[rustc_allow_const_fn_unstable(const_trait_impl)] #[must_use = "this returns the result of the operation, without modifying the original"] #[inline(always)] @@ -750,8 +750,8 @@ macro_rules! uint_impl { #[doc = concat!("`", stringify!($SelfT) , "::BITS`,")] /// i.e. when [`funnel_shr`](Self::funnel_shr) would panic. /// - #[rustc_const_stable(feature = "funnel_shifts", since = "CURRENT_RUSTC_VERSION")] - #[stable(feature = "funnel_shifts", since = "CURRENT_RUSTC_VERSION")] + #[rustc_const_stable(feature = "funnel_shifts", since = "1.101.0")] + #[stable(feature = "funnel_shifts", since = "1.101.0")] #[rustc_allow_const_fn_unstable(const_trait_impl)] #[must_use = "this returns the result of the operation, without modifying the original"] #[inline(always)] diff --git a/library/core/src/ops/function.rs b/library/core/src/ops/function.rs index 276b75c53cc38..d5dea51d3efda 100644 --- a/library/core/src/ops/function.rs +++ b/library/core/src/ops/function.rs @@ -325,30 +325,38 @@ unsafe extern "C" { pub type Code; } -/// A common trait implemented by all function pointers. +/// A common trait implemented by all function pointers and function definition types #[unstable(feature = "fn_static", issue = "148768")] -#[lang = "fn_ptr_trait"] -#[fundamental] +#[lang = "fn_addr_trait"] #[rustc_deny_explicit_impl] #[rustc_dyn_incompatible_trait] -pub trait FnPtr: Copy { +pub unsafe trait FnAddr: Copy { /// Returns the address of the function pointer. #[unstable(feature = "fn_static", issue = "148768")] + #[lang = "fn_addr_addr_fn"] fn addr(self) -> usize { self.as_ptr().addr().get() } /// Returns the function pointer as a [`NonNull`]. #[unstable(feature = "fn_static", issue = "148768")] - #[lang = "fn_ptr_as_ptr"] + #[lang = "fn_addr_as_ptr"] fn as_ptr(self) -> NonNull; +} +/// A common trait implemented by all function pointers. +#[unstable(feature = "fn_static", issue = "148768")] +#[lang = "fn_ptr_trait"] +#[fundamental] +#[rustc_deny_explicit_impl] +#[rustc_dyn_incompatible_trait] +pub unsafe trait FnPtr: FnAddr { /// Constructs a function pointer from a `NonNull` pointer. /// /// # Safety /// /// The function pointer must have been obtained - /// from an [`FnPtr::as_ptr`] call from a function + /// from an [`FnAddr::as_ptr`] call from a function /// pointer type that is ABI compatible. #[unstable(feature = "fn_static", issue = "148768")] #[lang = "fn_ptr_from_ptr"] diff --git a/library/core/src/ops/mod.rs b/library/core/src/ops/mod.rs index 9b5915a901aaa..5443c1ed4147a 100644 --- a/library/core/src/ops/mod.rs +++ b/library/core/src/ops/mod.rs @@ -177,7 +177,7 @@ pub use self::deref::{Deref, DerefMut}; #[stable(feature = "rust1", since = "1.0.0")] pub use self::drop::Drop; #[unstable(feature = "fn_static", issue = "148768")] -pub use self::function::{Code, FnPtr}; +pub use self::function::{Code, FnAddr, FnPtr}; #[stable(feature = "rust1", since = "1.0.0")] pub use self::function::{Fn, FnMut, FnOnce}; #[stable(feature = "rust1", since = "1.0.0")] diff --git a/library/core/src/pat.rs b/library/core/src/pat.rs index 0cf9f10fc8c28..1315c2a46d128 100644 --- a/library/core/src/pat.rs +++ b/library/core/src/pat.rs @@ -7,13 +7,11 @@ use crate::ops::{CoerceUnsized, DispatchFromDyn}; /// ```ignore (cannot test this from within core yet) /// type Positive = std::pat::pattern_type!(i32 is 1..); /// ``` -#[macro_export] -#[rustc_builtin_macro(pattern_type)] -#[unstable(feature = "pattern_type_macro", issue = "123646")] -macro_rules! pattern_type { - ($($arg:tt)*) => { - /* compiler built-in */ - }; +#[allow_internal_unstable(internal_syntax)] +#[unstable(feature = "pattern_types", issue = "123646")] +#[diagnostic::opaque] +pub macro pattern_type($( $arg:tt )*) { + k#pattern_type($( $arg )*) } /// A trait implemented for integer types and `char`. diff --git a/library/core/src/prelude/v1.rs b/library/core/src/prelude/v1.rs index f68d3e614c53f..d21fa351f5bce 100644 --- a/library/core/src/prelude/v1.rs +++ b/library/core/src/prelude/v1.rs @@ -104,9 +104,9 @@ pub use crate::const_format_args; #[doc(no_inline)] pub use crate::log_syntax; -#[unstable(feature = "pattern_type_macro", issue = "123646")] +#[unstable(feature = "pattern_types", issue = "123646")] #[doc(no_inline)] -pub use crate::pattern_type; +pub use crate::pat::pattern_type; #[unstable( feature = "trace_macros", diff --git a/library/core/src/ptr/const_ptr.rs b/library/core/src/ptr/const_ptr.rs index 054f44cf94cba..c934ee6f2d45c 100644 --- a/library/core/src/ptr/const_ptr.rs +++ b/library/core/src/ptr/const_ptr.rs @@ -65,7 +65,7 @@ impl *const T { /// assert!(aligned.try_cast_aligned::().is_some()); /// assert!(unaligned.try_cast_aligned::().is_none()); /// ``` - #[stable(feature = "pointer_try_cast_aligned", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "pointer_try_cast_aligned", since = "1.101.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -1422,8 +1422,8 @@ impl *const T { /// } /// ``` #[inline] - #[stable(feature = "ptr_cast_slice", since = "CURRENT_RUSTC_VERSION")] - #[rustc_const_stable(feature = "ptr_cast_slice", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "ptr_cast_slice", since = "1.101.0")] + #[rustc_const_stable(feature = "ptr_cast_slice", since = "1.101.0")] pub const fn cast_slice(self, len: usize) -> *const [T] { slice_from_raw_parts(self, len) } diff --git a/library/core/src/ptr/mut_ptr.rs b/library/core/src/ptr/mut_ptr.rs index 926d03892ad0d..25476de067c3c 100644 --- a/library/core/src/ptr/mut_ptr.rs +++ b/library/core/src/ptr/mut_ptr.rs @@ -48,7 +48,7 @@ impl *mut T { /// assert!(aligned.try_cast_aligned::().is_some()); /// assert!(unaligned.try_cast_aligned::().is_none()); /// ``` - #[stable(feature = "pointer_try_cast_aligned", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "pointer_try_cast_aligned", since = "1.101.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -1720,8 +1720,8 @@ impl *mut T { /// } /// ``` #[inline] - #[stable(feature = "ptr_cast_slice", since = "CURRENT_RUSTC_VERSION")] - #[rustc_const_stable(feature = "ptr_cast_slice", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "ptr_cast_slice", since = "1.101.0")] + #[rustc_const_stable(feature = "ptr_cast_slice", since = "1.101.0")] pub const fn cast_slice(self, len: usize) -> *mut [T] { slice_from_raw_parts_mut(self, len) } diff --git a/library/core/src/ptr/non_null.rs b/library/core/src/ptr/non_null.rs index 7d444cc8698a5..826da28aee4d2 100644 --- a/library/core/src/ptr/non_null.rs +++ b/library/core/src/ptr/non_null.rs @@ -76,7 +76,7 @@ use crate::{fmt, hash, intrinsics, mem, ptr}; #[rustc_nonnull_optimization_guaranteed] #[lang = "non_null"] pub struct NonNull<#[rustc_assert_variance(covariant)] T: PointeeSized> { - pointer: crate::pattern_type!(*const T is !null), + pointer: crate::pat::pattern_type!(*const T is !null), } /// `NonNull` pointers are not `Send` because the data they reference may be aliased. @@ -531,7 +531,7 @@ impl NonNull { /// assert!(aligned.try_cast_aligned::().is_some()); /// assert!(unaligned.try_cast_aligned::().is_none()); /// ``` - #[stable(feature = "pointer_try_cast_aligned", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "pointer_try_cast_aligned", since = "1.101.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -1389,8 +1389,8 @@ impl NonNull { /// but `let slice = NonNull::from(&x[..]);` would be a better way to write code like this.) #[inline] #[must_use] - #[stable(feature = "ptr_cast_slice", since = "CURRENT_RUSTC_VERSION")] - #[rustc_const_stable(feature = "ptr_cast_slice", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "ptr_cast_slice", since = "1.101.0")] + #[rustc_const_stable(feature = "ptr_cast_slice", since = "1.101.0")] pub const fn cast_slice(self, len: usize) -> NonNull<[T]> { NonNull::slice_from_raw_parts(self, len) } diff --git a/library/core/src/result.rs b/library/core/src/result.rs index 255c93bd8109c..33695d16145ba 100644 --- a/library/core/src/result.rs +++ b/library/core/src/result.rs @@ -1350,7 +1350,7 @@ impl Result { /// let s: String = only_good_news().into_ok(); /// println!("{s}"); /// ``` - #[stable(feature = "unwrap_infallible", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "unwrap_infallible", since = "1.101.0")] #[inline] #[rustc_allow_const_fn_unstable(const_precise_live_drops)] #[rustc_const_unstable(feature = "const_convert", issue = "143773")] @@ -1384,7 +1384,7 @@ impl Result { /// let error: String = only_bad_news().into_err(); /// println!("{error}"); /// ``` - #[stable(feature = "unwrap_infallible", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "unwrap_infallible", since = "1.101.0")] #[inline] #[rustc_allow_const_fn_unstable(const_precise_live_drops)] #[rustc_const_unstable(feature = "const_convert", issue = "143773")] diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs index f62dcce8df324..be0162e9ccc5e 100644 --- a/library/core/src/slice/mod.rs +++ b/library/core/src/slice/mod.rs @@ -2530,7 +2530,7 @@ impl [T] { /// ))); /// assert_eq!(s.split_once(|&x| x == 0), None); /// ``` - #[stable(feature = "slice_split_once", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "slice_split_once", since = "1.101.0")] #[inline] pub fn split_once(&self, pred: F) -> Option<(&[T], &[T])> where @@ -2558,7 +2558,7 @@ impl [T] { /// ))); /// assert_eq!(s.rsplit_once(|&x| x == 0), None); /// ``` - #[stable(feature = "slice_split_once", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "slice_split_once", since = "1.101.0")] #[inline] pub fn rsplit_once(&self, pred: F) -> Option<(&[T], &[T])> where diff --git a/library/core/src/sync/mod.rs b/library/core/src/sync/mod.rs index bd85bffcf192a..e73bbec700410 100644 --- a/library/core/src/sync/mod.rs +++ b/library/core/src/sync/mod.rs @@ -4,5 +4,5 @@ pub mod atomic; mod sync_view; -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] pub use sync_view::SyncView; diff --git a/library/core/src/sync/sync_view.rs b/library/core/src/sync/sync_view.rs index 5c1e24125cf74..274891b4f125b 100644 --- a/library/core/src/sync/sync_view.rs +++ b/library/core/src/sync/sync_view.rs @@ -89,7 +89,7 @@ use core::task::{Context, Poll}; /// for any value. This is a parallel with the fact that /// `&` and `&mut` references together can be thought of as a _compile-time_ /// version of a read-write lock. -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] #[doc(alias = "SyncWrapper")] #[doc(alias = "SyncCell")] #[doc(alias = "Unique")] @@ -103,10 +103,10 @@ pub struct SyncView { } // See `SyncView`'s docs for justification. -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] unsafe impl Sync for SyncView {} -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] #[rustc_const_unstable(feature = "const_default", issue = "143894")] const impl Default for SyncView where @@ -118,7 +118,7 @@ where } } -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] impl fmt::Debug for SyncView { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> { f.debug_struct("SyncView").finish_non_exhaustive() @@ -127,8 +127,8 @@ impl fmt::Debug for SyncView { impl SyncView { /// Wrap a value in an `SyncView` - #[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] - #[rustc_const_stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "exclusive_wrapper", since = "1.101.0")] + #[rustc_const_stable(feature = "exclusive_wrapper", since = "1.101.0")] #[must_use] #[inline] pub const fn new(t: T) -> Self { @@ -136,8 +136,8 @@ impl SyncView { } /// Unwrap the value contained in the `SyncView` - #[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] - #[rustc_const_stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "exclusive_wrapper", since = "1.101.0")] + #[rustc_const_stable(feature = "exclusive_wrapper", since = "1.101.0")] #[rustc_allow_const_fn_unstable(const_precise_live_drops)] #[must_use] #[inline] @@ -153,8 +153,8 @@ impl SyncView { /// value, which means _unpinned_ `SyncView`s can produce _unpinned_ /// access to the underlying value, but _pinned_ `SyncView`s only /// produce _pinned_ access to the underlying value. - #[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] - #[rustc_const_stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "exclusive_wrapper", since = "1.101.0")] + #[rustc_const_stable(feature = "exclusive_wrapper", since = "1.101.0")] #[must_use] #[inline] pub const fn as_pin_mut(self: Pin<&mut Self>) -> Pin<&mut T> { @@ -166,8 +166,8 @@ impl SyncView { /// Build a _mutable_ reference to an `SyncView` from /// a _mutable_ reference to a `T`. This allows you to skip /// building an `SyncView` with [`SyncView::new`]. - #[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] - #[rustc_const_stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "exclusive_wrapper", since = "1.101.0")] + #[rustc_const_stable(feature = "exclusive_wrapper", since = "1.101.0")] #[must_use] #[inline] pub const fn from_mut(r: &'_ mut T) -> &'_ mut SyncView { @@ -178,8 +178,8 @@ impl SyncView { /// Build a _pinned mutable_ reference to an `SyncView` from /// a _pinned mutable_ reference to a `T`. This allows you to skip /// building an `SyncView` with [`SyncView::new`]. - #[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] - #[rustc_const_stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "exclusive_wrapper", since = "1.101.0")] + #[rustc_const_stable(feature = "exclusive_wrapper", since = "1.101.0")] #[must_use] #[inline] pub const fn from_pin_mut(r: Pin<&'_ mut T>) -> Pin<&'_ mut SyncView> { @@ -196,8 +196,8 @@ impl SyncView { /// value, which means _unpinned_ `SyncView`s can produce _unpinned_ /// access to the underlying value, but _pinned_ `SyncView`s only /// produce _pinned_ access to the underlying value. - #[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] - #[rustc_const_stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "exclusive_wrapper", since = "1.101.0")] + #[rustc_const_stable(feature = "exclusive_wrapper", since = "1.101.0")] #[must_use] #[inline] pub const fn as_pin_ref(self: Pin<&Self>) -> Pin<&T> { @@ -207,7 +207,7 @@ impl SyncView { } } -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] #[rustc_const_unstable(feature = "const_convert", issue = "143773")] const impl From for SyncView { #[inline] @@ -216,7 +216,7 @@ const impl From for SyncView { } } -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] #[rustc_const_unstable(feature = "const_trait_impl", issue = "143874")] const impl FnOnce for SyncView where @@ -230,7 +230,7 @@ where } } -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] #[rustc_const_unstable(feature = "const_trait_impl", issue = "143874")] const impl FnMut for SyncView where @@ -242,7 +242,7 @@ where } } -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] #[rustc_const_unstable(feature = "const_trait_impl", issue = "143874")] const impl Fn for SyncView where @@ -254,7 +254,7 @@ where } } -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] impl AsyncFnOnce for SyncView where F: AsyncFnOnce, @@ -269,7 +269,7 @@ where } } -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] impl AsyncFnMut for SyncView where F: AsyncFnMut, @@ -285,7 +285,7 @@ where } } -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] impl AsyncFn for SyncView where F: Sync + AsyncFn, @@ -296,7 +296,7 @@ where } } -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] impl Future for SyncView where T: Future + ?Sized, @@ -323,7 +323,7 @@ where } } -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] #[rustc_const_unstable(feature = "const_convert", issue = "143773")] const impl AsRef for SyncView where @@ -336,7 +336,7 @@ where } } -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] #[rustc_const_unstable(feature = "const_convert", issue = "143773")] const impl AsMut for SyncView where @@ -349,7 +349,7 @@ where } } -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] #[rustc_const_unstable(feature = "const_clone", issue = "142757")] const impl Clone for SyncView where @@ -366,10 +366,10 @@ where #[rustc_const_unstable(feature = "const_clone", issue = "142757")] const unsafe impl TrivialClone for SyncView where T: Sync + [const] TrivialClone {} -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] impl Copy for SyncView where T: Sync + Copy {} -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] #[rustc_const_unstable(feature = "const_cmp", issue = "143800")] const impl PartialEq> for SyncView where @@ -382,14 +382,14 @@ where } } -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] impl StructuralPartialEq for SyncView where T: Sync + StructuralPartialEq + ?Sized {} -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] #[rustc_const_unstable(feature = "const_cmp", issue = "143800")] const impl Eq for SyncView where T: Sync + [const] Eq + ?Sized {} -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] impl Hash for SyncView where T: Sync + Hash + ?Sized, @@ -400,7 +400,7 @@ where } } -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] #[rustc_const_unstable(feature = "const_cmp", issue = "143800")] const impl PartialOrd> for SyncView where @@ -413,7 +413,7 @@ where } } -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] #[rustc_const_unstable(feature = "const_cmp", issue = "143800")] const impl Ord for SyncView where diff --git a/library/core/src/view.rs b/library/core/src/view.rs index 68eca3f3598d2..c68382b2effc9 100644 --- a/library/core/src/view.rs +++ b/library/core/src/view.rs @@ -2,7 +2,7 @@ /// Creates a view type. /// ``` -/// #![feature(view_types, view_type_macro)] +/// #![feature(view_types)] // /// struct Foo { /// bar: usize, @@ -11,11 +11,9 @@ /// /// type FooBar = std::view::view_type!(Foo.{ bar }); /// ``` -#[macro_export] -#[rustc_builtin_macro(view_type)] -#[unstable(feature = "view_type_macro", issue = "155938")] -macro_rules! view_type { - ($($arg:tt)*) => { - /* compiler built-in */ - }; +#[allow_internal_unstable(internal_syntax)] +#[unstable(feature = "view_types", issue = "155938")] +#[diagnostic::opaque] +pub macro view_type($($arg:tt)*) { + k#view_type($($arg)*) } diff --git a/library/proc_macro/src/bridge/arena.rs b/library/proc_macro/src/bridge/arena.rs index baa5dac461408..13fabf7e14f13 100644 --- a/library/proc_macro/src/bridge/arena.rs +++ b/library/proc_macro/src/bridge/arena.rs @@ -42,11 +42,10 @@ impl Arena { // arenas that are used for 100s of MiBs. Note also that the chosen sizes match // the usual sizes of pages and huge pages on Linux. const PAGE: usize = 4096; - const HUGE_PAGE: usize = - cfg_select! { - any(target_pointer_width = "64", target_pointer_width = "32") => 2 * 1024 * 1024, - _ => 8192, // just make it compile for -Zbuild-std - }; + const HUGE_PAGE: usize = cfg_select! { + any(target_pointer_width = "64", target_pointer_width = "32") => 2 * 1024 * 1024, + _ => 8192, // just make it compile for -Zbuild-std + }; let mut chunks = self.chunks.borrow_mut(); let mut new_cap; diff --git a/library/std/src/ffi/c_str.rs b/library/std/src/ffi/c_str.rs index e35acce2fef81..1d578deddd645 100644 --- a/library/std/src/ffi/c_str.rs +++ b/library/std/src/ffi/c_str.rs @@ -8,7 +8,7 @@ pub use alloc::ffi::c_str::IntoStringError; pub use alloc::ffi::c_str::{CString, NulError}; #[stable(feature = "rust1", since = "1.0.0")] pub use core::ffi::c_str::CStr; -#[stable(feature = "cstr_display", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "cstr_display", since = "1.101.0")] pub use core::ffi::c_str::Display; #[stable(feature = "cstr_from_bytes_until_nul", since = "1.69.0")] pub use core::ffi::c_str::FromBytesUntilNulError; diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs index 1f684c162496b..6b0d32f3ba5f2 100644 --- a/library/std/src/lib.rs +++ b/library/std/src/lib.rs @@ -641,7 +641,7 @@ pub mod num; #[allow(unreachable_pub)] pub mod os; pub mod panic; -#[unstable(feature = "pattern_type_macro", issue = "123646")] +#[unstable(feature = "pattern_types", issue = "123646")] pub mod pat; pub mod path; pub mod process; @@ -649,7 +649,7 @@ pub mod process; pub mod random; pub mod sync; pub mod time; -#[unstable(feature = "view_type_macro", issue = "155938")] +#[unstable(feature = "view_types", issue = "155938")] pub mod view; // Pull in `std_float` crate into std. The contents of diff --git a/library/std/src/os/windows/process.rs b/library/std/src/os/windows/process.rs index 5065026b21a46..422e5f172229d 100644 --- a/library/std/src/os/windows/process.rs +++ b/library/std/src/os/windows/process.rs @@ -398,10 +398,7 @@ pub impl(self) trait CommandExt { /// see the [Remarks][1] section of the `CreateProcessW` documentation. /// /// [1]: https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessw#remarks - #[stable( - feature = "windows_process_extensions_inherit_handles", - since = "CURRENT_RUSTC_VERSION" - )] + #[stable(feature = "windows_process_extensions_inherit_handles", since = "1.101.0")] fn inherit_handles(&mut self, inherit_handles: bool) -> &mut process::Command; } @@ -497,7 +494,7 @@ impl ChildExt for process::Child { } /// Windows-specific extensions to [`process::ExitCode`]. -#[stable(feature = "windows_process_exit_code_from", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "windows_process_exit_code_from", since = "1.101.0")] pub impl(self) trait ExitCodeExt { /// Creates a new `ExitCode` from the raw underlying `u32` return value of /// a process. @@ -505,11 +502,11 @@ pub impl(self) trait ExitCodeExt { /// The exit code should not be 259, as this conflicts with the `STILL_ACTIVE` /// macro returned from the `GetExitCodeProcess` function to signal that the /// process has yet to run to completion. - #[stable(feature = "windows_process_exit_code_from", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "windows_process_exit_code_from", since = "1.101.0")] fn from_raw(raw: u32) -> Self; } -#[stable(feature = "windows_process_exit_code_from", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "windows_process_exit_code_from", since = "1.101.0")] impl ExitCodeExt for process::ExitCode { #[rustdoc_skip_body] fn from_raw(raw: u32) -> Self { diff --git a/library/std/src/pat.rs b/library/std/src/pat.rs index aeddd84c2cb54..3d227b1903f33 100644 --- a/library/std/src/pat.rs +++ b/library/std/src/pat.rs @@ -1,3 +1,3 @@ //! Helper module for exporting the `pattern_type` macro -pub use core::pattern_type; +pub use core::pat::pattern_type; diff --git a/library/std/src/sync/mod.rs b/library/std/src/sync/mod.rs index b138c1b946c92..081cad45116da 100644 --- a/library/std/src/sync/mod.rs +++ b/library/std/src/sync/mod.rs @@ -179,7 +179,7 @@ #![cfg_attr(rustfmt, rustfmt::skip)] // These come from `core` & `alloc` and only in one flavor: no poisoning. -#[stable(feature = "exclusive_wrapper", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "exclusive_wrapper", since = "1.101.0")] pub use core::sync::SyncView; #[stable(feature = "rust1", since = "1.0.0")] pub use core::sync::atomic; diff --git a/library/std/src/sys/fd/unix.rs b/library/std/src/sys/fd/unix.rs index c46ca0cd4d591..3166f8b7aacb7 100644 --- a/library/std/src/sys/fd/unix.rs +++ b/library/std/src/sys/fd/unix.rs @@ -30,8 +30,11 @@ cfg_select! { -1 } } - any(all(target_os = "linux", not(target_env = "musl")), target_os = "android", target_os = "hurd") => - { + any( + all(target_os = "linux", not(target_env = "musl")), + target_os = "android", + target_os = "hurd" + ) => { // Prefer explicit pread64 for 64-bit offset independently of libc // #[cfg(gnu_file_offset_bits64)]. use libc::{pread64, pwrite64}; @@ -68,9 +71,7 @@ pub struct FileDesc(OwnedFd); // number of bytes written (eg, writing 2^31 bytes returns (2^64 - 2^31) instead // of the correct byte count). const READ_LIMIT: usize = cfg_select! { - any(target_vendor = "apple", target_os = "nto", target_os = "qnx") => { - libc::c_int::MAX as usize - } + any(target_vendor = "apple", target_os = "nto", target_os = "qnx") => libc::c_int::MAX as usize, _ => libc::ssize_t::MAX as usize, }; diff --git a/library/std/src/sys/fs/unix/dir.rs b/library/std/src/sys/fs/unix/dir.rs index 2ac5695e3d72a..7a870024240fb 100644 --- a/library/std/src/sys/fs/unix/dir.rs +++ b/library/std/src/sys/fs/unix/dir.rs @@ -28,13 +28,12 @@ use crate::sys::helpers::run_path_with_cstr; use crate::sys::{AsInner, FromInner, IntoInner, cvt, cvt_r}; use crate::{fmt, fs, io, mem}; -const TRAVERSE_DIRECTORY: i32 = - cfg_select! { - any(target_os = "freebsd", target_os = "aix") => libc::O_EXEC, - any(target_os = "linux", target_os = "android", target_os = "l4re") => libc::O_PATH, - target_os = "illumos" => libc::O_SEARCH, - _ => libc::O_RDONLY, - }; +const TRAVERSE_DIRECTORY: i32 = cfg_select! { + any(target_os = "freebsd", target_os = "aix") => libc::O_EXEC, + any(target_os = "linux", target_os = "android", target_os = "l4re") => libc::O_PATH, + target_os = "illumos" => libc::O_SEARCH, + _ => libc::O_RDONLY, +}; pub struct Dir(pub(super) OwnedFd); diff --git a/library/std/src/sys/net/connection/socket/mod.rs b/library/std/src/sys/net/connection/socket/mod.rs index 67be140cc313c..7fbd12e325385 100644 --- a/library/std/src/sys/net/connection/socket/mod.rs +++ b/library/std/src/sys/net/connection/socket/mod.rs @@ -50,12 +50,11 @@ use netc as c; // // On Windows, the relevant syscall takes an `i32` (unlike for read/write!), // so we need to clamp to i32::MAX. -const MAX_SEND_LEN: usize = - cfg_select! { - any(target_vendor = "apple", target_os = "nto", target_os = "qnx") => c_int::MAX as usize, - target_os = "windows" => i32::MAX as usize, - _ => libc::ssize_t::MAX as usize, - }; +const MAX_SEND_LEN: usize = cfg_select! { + any(target_vendor = "apple", target_os = "nto", target_os = "qnx") => c_int::MAX as usize, + target_os = "windows" => i32::MAX as usize, + _ => libc::ssize_t::MAX as usize, +}; /// Some systems support setting the nonblocking mode upon socket creation, which /// saves a syscall. diff --git a/library/std/src/view.rs b/library/std/src/view.rs index 5806cf27c2cc8..3e0e7d1d1038a 100644 --- a/library/std/src/view.rs +++ b/library/std/src/view.rs @@ -1,3 +1,3 @@ //! Helper module for exporting the `view_types` macro. -pub use core::view_type; +pub use core::view::view_type; diff --git a/library/stdarch/crates/core_arch/src/loongarch64/lasx/generated.rs b/library/stdarch/crates/core_arch/src/loongarch64/lasx/generated.rs index 75b79398bf9c7..add717da9c493 100644 --- a/library/stdarch/crates/core_arch/src/loongarch64/lasx/generated.rs +++ b/library/stdarch/crates/core_arch/src/loongarch64/lasx/generated.rs @@ -941,35 +941,35 @@ unsafe extern "llvm-intrinsic" { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrar_b(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsrar_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrar_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsrar_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrar_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsrar_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrar_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsrar_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrari_b(a: m256i) -> m256i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lasx_xvsrari_b(transmute(a), IMM3)) } @@ -977,7 +977,7 @@ pub fn lasx_xvsrari_b(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrari_h(a: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvsrari_h(transmute(a), IMM4)) } @@ -985,7 +985,7 @@ pub fn lasx_xvsrari_h(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrari_w(a: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvsrari_w(transmute(a), IMM5)) } @@ -993,7 +993,7 @@ pub fn lasx_xvsrari_w(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrari_d(a: m256i) -> m256i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lasx_xvsrari_d(transmute(a), IMM6)) } @@ -1001,35 +1001,35 @@ pub fn lasx_xvsrari_d(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrlr_b(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsrlr_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrlr_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsrlr_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrlr_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsrlr_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrlr_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsrlr_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrlri_b(a: m256i) -> m256i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lasx_xvsrlri_b(transmute(a), IMM3)) } @@ -1037,7 +1037,7 @@ pub fn lasx_xvsrlri_b(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrlri_h(a: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvsrlri_h(transmute(a), IMM4)) } @@ -1045,7 +1045,7 @@ pub fn lasx_xvsrlri_h(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrlri_w(a: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvsrlri_w(transmute(a), IMM5)) } @@ -1053,7 +1053,7 @@ pub fn lasx_xvsrlri_w(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrlri_d(a: m256i) -> m256i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lasx_xvsrlri_d(transmute(a), IMM6)) } @@ -1061,7 +1061,7 @@ pub fn lasx_xvsrlri_d(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvbitclri_b(a: m256i) -> m256i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lasx_xvbitclri_b(transmute(a), IMM3)) } @@ -1069,7 +1069,7 @@ pub fn lasx_xvbitclri_b(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvbitclri_h(a: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvbitclri_h(transmute(a), IMM4)) } @@ -1077,7 +1077,7 @@ pub fn lasx_xvbitclri_h(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvbitclri_w(a: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvbitclri_w(transmute(a), IMM5)) } @@ -1085,7 +1085,7 @@ pub fn lasx_xvbitclri_w(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvbitclri_d(a: m256i) -> m256i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lasx_xvbitclri_d(transmute(a), IMM6)) } @@ -1093,7 +1093,7 @@ pub fn lasx_xvbitclri_d(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvbitseti_b(a: m256i) -> m256i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lasx_xvbitseti_b(transmute(a), IMM3)) } @@ -1101,7 +1101,7 @@ pub fn lasx_xvbitseti_b(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvbitseti_h(a: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvbitseti_h(transmute(a), IMM4)) } @@ -1109,7 +1109,7 @@ pub fn lasx_xvbitseti_h(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvbitseti_w(a: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvbitseti_w(transmute(a), IMM5)) } @@ -1117,7 +1117,7 @@ pub fn lasx_xvbitseti_w(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvbitseti_d(a: m256i) -> m256i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lasx_xvbitseti_d(transmute(a), IMM6)) } @@ -1125,7 +1125,7 @@ pub fn lasx_xvbitseti_d(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvbitrevi_b(a: m256i) -> m256i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lasx_xvbitrevi_b(transmute(a), IMM3)) } @@ -1133,7 +1133,7 @@ pub fn lasx_xvbitrevi_b(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvbitrevi_h(a: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvbitrevi_h(transmute(a), IMM4)) } @@ -1141,7 +1141,7 @@ pub fn lasx_xvbitrevi_h(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvbitrevi_w(a: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvbitrevi_w(transmute(a), IMM5)) } @@ -1149,7 +1149,7 @@ pub fn lasx_xvbitrevi_w(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvbitrevi_d(a: m256i) -> m256i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lasx_xvbitrevi_d(transmute(a), IMM6)) } @@ -1157,7 +1157,7 @@ pub fn lasx_xvbitrevi_d(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubi_bu(a: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvsubi_bu(transmute(a), IMM5)) } @@ -1165,7 +1165,7 @@ pub fn lasx_xvsubi_bu(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubi_hu(a: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvsubi_hu(transmute(a), IMM5)) } @@ -1173,7 +1173,7 @@ pub fn lasx_xvsubi_hu(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubi_wu(a: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvsubi_wu(transmute(a), IMM5)) } @@ -1181,7 +1181,7 @@ pub fn lasx_xvsubi_wu(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubi_du(a: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvsubi_du(transmute(a), IMM5)) } @@ -1189,7 +1189,7 @@ pub fn lasx_xvsubi_du(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsat_b(a: m256i) -> m256i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lasx_xvsat_b(transmute(a), IMM3)) } @@ -1197,7 +1197,7 @@ pub fn lasx_xvsat_b(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsat_h(a: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvsat_h(transmute(a), IMM4)) } @@ -1205,7 +1205,7 @@ pub fn lasx_xvsat_h(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsat_w(a: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvsat_w(transmute(a), IMM5)) } @@ -1213,7 +1213,7 @@ pub fn lasx_xvsat_w(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsat_d(a: m256i) -> m256i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lasx_xvsat_d(transmute(a), IMM6)) } @@ -1221,7 +1221,7 @@ pub fn lasx_xvsat_d(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsat_bu(a: m256i) -> m256i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lasx_xvsat_bu(transmute(a), IMM3)) } @@ -1229,7 +1229,7 @@ pub fn lasx_xvsat_bu(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsat_hu(a: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvsat_hu(transmute(a), IMM4)) } @@ -1237,7 +1237,7 @@ pub fn lasx_xvsat_hu(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsat_wu(a: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvsat_wu(transmute(a), IMM5)) } @@ -1245,7 +1245,7 @@ pub fn lasx_xvsat_wu(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsat_du(a: m256i) -> m256i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lasx_xvsat_du(transmute(a), IMM6)) } @@ -1253,231 +1253,231 @@ pub fn lasx_xvsat_du(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvdiv_b(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvdiv_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvdiv_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvdiv_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvdiv_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvdiv_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvdiv_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvdiv_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvdiv_bu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvdiv_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvdiv_hu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvdiv_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvdiv_wu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvdiv_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvdiv_du(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvdiv_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvhaddw_h_b(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvhaddw_h_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvhaddw_w_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvhaddw_w_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvhaddw_d_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvhaddw_d_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvhaddw_hu_bu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvhaddw_hu_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvhaddw_wu_hu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvhaddw_wu_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvhaddw_du_wu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvhaddw_du_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvhsubw_h_b(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvhsubw_h_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvhsubw_w_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvhsubw_w_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvhsubw_d_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvhsubw_d_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvhsubw_hu_bu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvhsubw_hu_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvhsubw_wu_hu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvhsubw_wu_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvhsubw_du_wu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvhsubw_du_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmod_b(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmod_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmod_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmod_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmod_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmod_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmod_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmod_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmod_bu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmod_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmod_hu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmod_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmod_wu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmod_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmod_du(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmod_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvshuf_b(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvshuf_b(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvshuf_h(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvshuf_h(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvshuf_w(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvshuf_w(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvshuf_d(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvshuf_d(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvandi_b(a: m256i) -> m256i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lasx_xvandi_b(transmute(a), IMM8)) } @@ -1485,7 +1485,7 @@ pub fn lasx_xvandi_b(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvori_b(a: m256i) -> m256i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lasx_xvori_b(transmute(a), IMM8)) } @@ -1493,7 +1493,7 @@ pub fn lasx_xvori_b(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvnori_b(a: m256i) -> m256i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lasx_xvnori_b(transmute(a), IMM8)) } @@ -1501,7 +1501,7 @@ pub fn lasx_xvnori_b(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvxori_b(a: m256i) -> m256i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lasx_xvxori_b(transmute(a), IMM8)) } @@ -1509,14 +1509,14 @@ pub fn lasx_xvxori_b(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvbitsel_v(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvbitsel_v(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvbitseli_b(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lasx_xvbitseli_b(transmute(a), transmute(b), IMM8)) } @@ -1524,315 +1524,315 @@ pub fn lasx_xvbitseli_b(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvclo_b(a: m256i) -> m256i { unsafe { transmute(__lasx_xvclo_b(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvclo_h(a: m256i) -> m256i { unsafe { transmute(__lasx_xvclo_h(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvclo_w(a: m256i) -> m256i { unsafe { transmute(__lasx_xvclo_w(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvclo_d(a: m256i) -> m256i { unsafe { transmute(__lasx_xvclo_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcvt_h_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcvt_h_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcvt_s_d(a: m256d, b: m256d) -> m256 { unsafe { transmute(__lasx_xvfcvt_s_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfmin_s(a: m256, b: m256) -> m256 { unsafe { transmute(__lasx_xvfmin_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfmin_d(a: m256d, b: m256d) -> m256d { unsafe { transmute(__lasx_xvfmin_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfmina_s(a: m256, b: m256) -> m256 { unsafe { transmute(__lasx_xvfmina_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfmina_d(a: m256d, b: m256d) -> m256d { unsafe { transmute(__lasx_xvfmina_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfmax_s(a: m256, b: m256) -> m256 { unsafe { transmute(__lasx_xvfmax_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfmax_d(a: m256d, b: m256d) -> m256d { unsafe { transmute(__lasx_xvfmax_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfmaxa_s(a: m256, b: m256) -> m256 { unsafe { transmute(__lasx_xvfmaxa_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfmaxa_d(a: m256d, b: m256d) -> m256d { unsafe { transmute(__lasx_xvfmaxa_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfclass_s(a: m256) -> m256i { unsafe { transmute(__lasx_xvfclass_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfclass_d(a: m256d) -> m256i { unsafe { transmute(__lasx_xvfclass_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx,frecipe")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfrecipe_s(a: m256) -> m256 { unsafe { transmute(__lasx_xvfrecipe_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx,frecipe")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfrecipe_d(a: m256d) -> m256d { unsafe { transmute(__lasx_xvfrecipe_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx,frecipe")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfrsqrte_s(a: m256) -> m256 { unsafe { transmute(__lasx_xvfrsqrte_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx,frecipe")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfrsqrte_d(a: m256d) -> m256d { unsafe { transmute(__lasx_xvfrsqrte_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfrint_s(a: m256) -> m256 { unsafe { transmute(__lasx_xvfrint_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfrint_d(a: m256d) -> m256d { unsafe { transmute(__lasx_xvfrint_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvflogb_s(a: m256) -> m256 { unsafe { transmute(__lasx_xvflogb_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvflogb_d(a: m256d) -> m256d { unsafe { transmute(__lasx_xvflogb_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcvth_s_h(a: m256i) -> m256 { unsafe { transmute(__lasx_xvfcvth_s_h(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcvth_d_s(a: m256) -> m256d { unsafe { transmute(__lasx_xvfcvth_d_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcvtl_s_h(a: m256i) -> m256 { unsafe { transmute(__lasx_xvfcvtl_s_h(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcvtl_d_s(a: m256) -> m256d { unsafe { transmute(__lasx_xvfcvtl_d_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftint_w_s(a: m256) -> m256i { unsafe { transmute(__lasx_xvftint_w_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftint_l_d(a: m256d) -> m256i { unsafe { transmute(__lasx_xvftint_l_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftint_wu_s(a: m256) -> m256i { unsafe { transmute(__lasx_xvftint_wu_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftint_lu_d(a: m256d) -> m256i { unsafe { transmute(__lasx_xvftint_lu_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrz_w_s(a: m256) -> m256i { unsafe { transmute(__lasx_xvftintrz_w_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrz_l_d(a: m256d) -> m256i { unsafe { transmute(__lasx_xvftintrz_l_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrz_wu_s(a: m256) -> m256i { unsafe { transmute(__lasx_xvftintrz_wu_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrz_lu_d(a: m256d) -> m256i { unsafe { transmute(__lasx_xvftintrz_lu_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvffint_s_w(a: m256i) -> m256 { unsafe { transmute(__lasx_xvffint_s_w(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvffint_d_l(a: m256i) -> m256d { unsafe { transmute(__lasx_xvffint_d_l(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvffint_s_wu(a: m256i) -> m256 { unsafe { transmute(__lasx_xvffint_s_wu(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvffint_d_lu(a: m256i) -> m256d { unsafe { transmute(__lasx_xvffint_d_lu(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvreplve_b(a: m256i, b: i32) -> m256i { unsafe { transmute(__lasx_xvreplve_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvreplve_h(a: m256i, b: i32) -> m256i { unsafe { transmute(__lasx_xvreplve_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvreplve_w(a: m256i, b: i32) -> m256i { unsafe { transmute(__lasx_xvreplve_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvreplve_d(a: m256i, b: i32) -> m256i { unsafe { transmute(__lasx_xvreplve_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvpermi_w(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lasx_xvpermi_w(transmute(a), transmute(b), IMM8)) } @@ -1840,7 +1840,7 @@ pub fn lasx_xvpermi_w(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsllwil_h_b(a: m256i) -> m256i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lasx_xvsllwil_h_b(transmute(a), IMM3)) } @@ -1848,7 +1848,7 @@ pub fn lasx_xvsllwil_h_b(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsllwil_w_h(a: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvsllwil_w_h(transmute(a), IMM4)) } @@ -1856,7 +1856,7 @@ pub fn lasx_xvsllwil_w_h(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsllwil_d_w(a: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvsllwil_d_w(transmute(a), IMM5)) } @@ -1864,7 +1864,7 @@ pub fn lasx_xvsllwil_d_w(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsllwil_hu_bu(a: m256i) -> m256i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lasx_xvsllwil_hu_bu(transmute(a), IMM3)) } @@ -1872,7 +1872,7 @@ pub fn lasx_xvsllwil_hu_bu(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsllwil_wu_hu(a: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvsllwil_wu_hu(transmute(a), IMM4)) } @@ -1880,7 +1880,7 @@ pub fn lasx_xvsllwil_wu_hu(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsllwil_du_wu(a: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvsllwil_du_wu(transmute(a), IMM5)) } @@ -1888,217 +1888,217 @@ pub fn lasx_xvsllwil_du_wu(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsran_b_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsran_b_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsran_h_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsran_h_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsran_w_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsran_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssran_b_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssran_b_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssran_h_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssran_h_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssran_w_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssran_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssran_bu_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssran_bu_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssran_hu_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssran_hu_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssran_wu_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssran_wu_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrarn_b_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsrarn_b_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrarn_h_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsrarn_h_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrarn_w_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsrarn_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrarn_b_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssrarn_b_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrarn_h_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssrarn_h_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrarn_w_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssrarn_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrarn_bu_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssrarn_bu_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrarn_hu_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssrarn_hu_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrarn_wu_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssrarn_wu_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrln_b_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsrln_b_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrln_h_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsrln_h_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrln_w_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsrln_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrln_bu_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssrln_bu_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrln_hu_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssrln_hu_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrln_wu_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssrln_wu_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrlrn_b_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsrlrn_b_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrlrn_h_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsrlrn_h_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrlrn_w_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsrlrn_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlrn_bu_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssrlrn_bu_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlrn_hu_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssrlrn_hu_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlrn_wu_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssrlrn_wu_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfrstpi_b(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvfrstpi_b(transmute(a), transmute(b), IMM5)) } @@ -2106,7 +2106,7 @@ pub fn lasx_xvfrstpi_b(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfrstpi_h(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvfrstpi_h(transmute(a), transmute(b), IMM5)) } @@ -2114,21 +2114,21 @@ pub fn lasx_xvfrstpi_h(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfrstp_b(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvfrstp_b(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfrstp_h(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvfrstp_h(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvshuf4i_d(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lasx_xvshuf4i_d(transmute(a), transmute(b), IMM8)) } @@ -2136,7 +2136,7 @@ pub fn lasx_xvshuf4i_d(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvextrins_b(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lasx_xvextrins_b(transmute(a), transmute(b), IMM8)) } @@ -2144,7 +2144,7 @@ pub fn lasx_xvextrins_b(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvextrins_h(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lasx_xvextrins_h(transmute(a), transmute(b), IMM8)) } @@ -2152,7 +2152,7 @@ pub fn lasx_xvextrins_h(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvextrins_w(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lasx_xvextrins_w(transmute(a), transmute(b), IMM8)) } @@ -2160,7 +2160,7 @@ pub fn lasx_xvextrins_w(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvextrins_d(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lasx_xvextrins_d(transmute(a), transmute(b), IMM8)) } @@ -2168,245 +2168,245 @@ pub fn lasx_xvextrins_d(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmskltz_b(a: m256i) -> m256i { unsafe { transmute(__lasx_xvmskltz_b(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmskltz_h(a: m256i) -> m256i { unsafe { transmute(__lasx_xvmskltz_h(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmskltz_w(a: m256i) -> m256i { unsafe { transmute(__lasx_xvmskltz_w(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmskltz_d(a: m256i) -> m256i { unsafe { transmute(__lasx_xvmskltz_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsigncov_b(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsigncov_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsigncov_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsigncov_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsigncov_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsigncov_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsigncov_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsigncov_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrne_w_s(a: m256) -> m256i { unsafe { transmute(__lasx_xvftintrne_w_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrne_l_d(a: m256d) -> m256i { unsafe { transmute(__lasx_xvftintrne_l_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrp_w_s(a: m256) -> m256i { unsafe { transmute(__lasx_xvftintrp_w_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrp_l_d(a: m256d) -> m256i { unsafe { transmute(__lasx_xvftintrp_l_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrm_w_s(a: m256) -> m256i { unsafe { transmute(__lasx_xvftintrm_w_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrm_l_d(a: m256d) -> m256i { unsafe { transmute(__lasx_xvftintrm_l_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftint_w_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvftint_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvffint_s_l(a: m256i, b: m256i) -> m256 { unsafe { transmute(__lasx_xvffint_s_l(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrz_w_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvftintrz_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrp_w_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvftintrp_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrm_w_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvftintrm_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrne_w_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvftintrne_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftinth_l_s(a: m256) -> m256i { unsafe { transmute(__lasx_xvftinth_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintl_l_s(a: m256) -> m256i { unsafe { transmute(__lasx_xvftintl_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvffinth_d_w(a: m256i) -> m256d { unsafe { transmute(__lasx_xvffinth_d_w(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvffintl_d_w(a: m256i) -> m256d { unsafe { transmute(__lasx_xvffintl_d_w(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrzh_l_s(a: m256) -> m256i { unsafe { transmute(__lasx_xvftintrzh_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrzl_l_s(a: m256) -> m256i { unsafe { transmute(__lasx_xvftintrzl_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrph_l_s(a: m256) -> m256i { unsafe { transmute(__lasx_xvftintrph_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrpl_l_s(a: m256) -> m256i { unsafe { transmute(__lasx_xvftintrpl_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrmh_l_s(a: m256) -> m256i { unsafe { transmute(__lasx_xvftintrmh_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrml_l_s(a: m256) -> m256i { unsafe { transmute(__lasx_xvftintrml_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrneh_l_s(a: m256) -> m256i { unsafe { transmute(__lasx_xvftintrneh_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvftintrnel_l_s(a: m256) -> m256i { unsafe { transmute(__lasx_xvftintrnel_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfrintrne_s(a: m256) -> m256 { unsafe { transmute(__lasx_xvfrintrne_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfrintrne_d(a: m256d) -> m256d { unsafe { transmute(__lasx_xvfrintrne_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn lasx_xvstelm_b(a: m256i, mem_addr: *mut i8) { static_assert_simm_bits!(IMM_S8, 8); static_assert_uimm_bits!(IMM4, 4); @@ -2415,7 +2415,7 @@ pub unsafe fn lasx_xvstelm_b(a: m256i, mem_a #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn lasx_xvstelm_h(a: m256i, mem_addr: *mut i8) { static_assert_simm_bits!(IMM_S8, 8); static_assert_uimm_bits!(IMM3, 3); @@ -2424,7 +2424,7 @@ pub unsafe fn lasx_xvstelm_h(a: m256i, mem_a #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn lasx_xvstelm_w(a: m256i, mem_addr: *mut i8) { static_assert_simm_bits!(IMM_S8, 8); static_assert_uimm_bits!(IMM2, 2); @@ -2433,7 +2433,7 @@ pub unsafe fn lasx_xvstelm_w(a: m256i, mem_a #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn lasx_xvstelm_d(a: m256i, mem_addr: *mut i8) { static_assert_simm_bits!(IMM_S8, 8); static_assert_uimm_bits!(IMM1, 1); @@ -2442,7 +2442,7 @@ pub unsafe fn lasx_xvstelm_d(a: m256i, mem_a #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvinsve0_w(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lasx_xvinsve0_w(transmute(a), transmute(b), IMM3)) } @@ -2450,7 +2450,7 @@ pub fn lasx_xvinsve0_w(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvinsve0_d(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM2, 2); unsafe { transmute(__lasx_xvinsve0_d(transmute(a), transmute(b), IMM2)) } @@ -2458,7 +2458,7 @@ pub fn lasx_xvinsve0_d(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvpickve_w(a: m256i) -> m256i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lasx_xvpickve_w(transmute(a), IMM3)) } @@ -2466,7 +2466,7 @@ pub fn lasx_xvpickve_w(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvpickve_d(a: m256i) -> m256i { static_assert_uimm_bits!(IMM2, 2); unsafe { transmute(__lasx_xvpickve_d(transmute(a), IMM2)) } @@ -2474,140 +2474,140 @@ pub fn lasx_xvpickve_d(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlrn_b_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssrlrn_b_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlrn_h_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssrlrn_h_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlrn_w_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssrlrn_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrln_b_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssrln_b_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrln_h_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssrln_h_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrln_w_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvssrln_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvextl_qu_du(a: m256i) -> m256i { unsafe { transmute(__lasx_xvextl_qu_du(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_vext2xv_h_b(a: m256i) -> m256i { unsafe { transmute(__lasx_vext2xv_h_b(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_vext2xv_w_h(a: m256i) -> m256i { unsafe { transmute(__lasx_vext2xv_w_h(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_vext2xv_d_w(a: m256i) -> m256i { unsafe { transmute(__lasx_vext2xv_d_w(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_vext2xv_w_b(a: m256i) -> m256i { unsafe { transmute(__lasx_vext2xv_w_b(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_vext2xv_d_h(a: m256i) -> m256i { unsafe { transmute(__lasx_vext2xv_d_h(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_vext2xv_d_b(a: m256i) -> m256i { unsafe { transmute(__lasx_vext2xv_d_b(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_vext2xv_hu_bu(a: m256i) -> m256i { unsafe { transmute(__lasx_vext2xv_hu_bu(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_vext2xv_wu_hu(a: m256i) -> m256i { unsafe { transmute(__lasx_vext2xv_wu_hu(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_vext2xv_du_wu(a: m256i) -> m256i { unsafe { transmute(__lasx_vext2xv_du_wu(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_vext2xv_wu_bu(a: m256i) -> m256i { unsafe { transmute(__lasx_vext2xv_wu_bu(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_vext2xv_du_hu(a: m256i) -> m256i { unsafe { transmute(__lasx_vext2xv_du_hu(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_vext2xv_du_bu(a: m256i) -> m256i { unsafe { transmute(__lasx_vext2xv_du_bu(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvpermi_q(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lasx_xvpermi_q(transmute(a), transmute(b), IMM8)) } @@ -2615,7 +2615,7 @@ pub fn lasx_xvpermi_q(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvpermi_d(a: m256i) -> m256i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lasx_xvpermi_d(transmute(a), IMM8)) } @@ -2623,14 +2623,14 @@ pub fn lasx_xvpermi_d(a: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvperm_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvperm_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn lasx_xvldrepl_b(mem_addr: *const i8) -> m256i { static_assert_simm_bits!(IMM_S12, 12); transmute(__lasx_xvldrepl_b(mem_addr, IMM_S12)) @@ -2638,7 +2638,7 @@ pub unsafe fn lasx_xvldrepl_b(mem_addr: *const i8) -> m256i #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn lasx_xvldrepl_h(mem_addr: *const i8) -> m256i { static_assert_simm_bits!(IMM_S11, 11); transmute(__lasx_xvldrepl_h(mem_addr, IMM_S11)) @@ -2646,7 +2646,7 @@ pub unsafe fn lasx_xvldrepl_h(mem_addr: *const i8) -> m256i #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn lasx_xvldrepl_w(mem_addr: *const i8) -> m256i { static_assert_simm_bits!(IMM_S10, 10); transmute(__lasx_xvldrepl_w(mem_addr, IMM_S10)) @@ -2654,7 +2654,7 @@ pub unsafe fn lasx_xvldrepl_w(mem_addr: *const i8) -> m256i #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn lasx_xvldrepl_d(mem_addr: *const i8) -> m256i { static_assert_simm_bits!(IMM_S9, 9); transmute(__lasx_xvldrepl_d(mem_addr, IMM_S9)) @@ -2662,455 +2662,455 @@ pub unsafe fn lasx_xvldrepl_d(mem_addr: *const i8) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwev_q_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwev_q_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwev_d_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwev_d_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwev_w_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwev_w_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwev_h_b(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwev_h_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwev_q_du(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwev_q_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwev_d_wu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwev_d_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwev_w_hu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwev_w_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwev_h_bu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwev_h_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubwev_q_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsubwev_q_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubwev_d_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsubwev_d_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubwev_w_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsubwev_w_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubwev_h_b(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsubwev_h_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubwev_q_du(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsubwev_q_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubwev_d_wu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsubwev_d_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubwev_w_hu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsubwev_w_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubwev_h_bu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsubwev_h_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwev_q_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwev_q_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwev_d_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwev_d_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwev_w_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwev_w_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwev_h_b(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwev_h_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwev_q_du(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwev_q_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwev_d_wu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwev_d_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwev_w_hu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwev_w_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwev_h_bu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwev_h_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwod_q_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwod_q_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwod_d_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwod_d_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwod_w_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwod_w_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwod_h_b(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwod_h_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwod_q_du(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwod_q_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwod_d_wu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwod_d_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwod_w_hu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwod_w_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwod_h_bu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwod_h_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubwod_q_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsubwod_q_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubwod_d_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsubwod_d_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubwod_w_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsubwod_w_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubwod_h_b(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsubwod_h_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubwod_q_du(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsubwod_q_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubwod_d_wu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsubwod_d_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubwod_w_hu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsubwod_w_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsubwod_h_bu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsubwod_h_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwod_q_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwod_q_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwod_d_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwod_d_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwod_w_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwod_w_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwod_h_b(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwod_h_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwod_q_du(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwod_q_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwod_d_wu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwod_d_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwod_w_hu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwod_w_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwod_h_bu(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwod_h_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwev_d_wu_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwev_d_wu_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwev_w_hu_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwev_w_hu_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwev_h_bu_b(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwev_h_bu_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwev_d_wu_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwev_d_wu_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwev_w_hu_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwev_w_hu_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwev_h_bu_b(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwev_h_bu_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwod_d_wu_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwod_d_wu_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwod_w_hu_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwod_w_hu_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwod_h_bu_b(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwod_h_bu_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwod_d_wu_w(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwod_d_wu_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwod_w_hu_h(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwod_w_hu_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwod_h_bu_b(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwod_h_bu_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvhaddw_q_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvhaddw_q_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvhaddw_qu_du(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvhaddw_qu_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvhsubw_q_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvhsubw_q_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvhsubw_qu_du(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvhsubw_qu_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwev_q_d(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwev_q_d( @@ -3123,7 +3123,7 @@ pub fn lasx_xvmaddwev_q_d(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwev_d_w(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwev_d_w( @@ -3136,7 +3136,7 @@ pub fn lasx_xvmaddwev_d_w(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwev_w_h(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwev_w_h( @@ -3149,7 +3149,7 @@ pub fn lasx_xvmaddwev_w_h(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwev_h_b(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwev_h_b( @@ -3162,7 +3162,7 @@ pub fn lasx_xvmaddwev_h_b(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwev_q_du(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwev_q_du( @@ -3175,7 +3175,7 @@ pub fn lasx_xvmaddwev_q_du(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwev_d_wu(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwev_d_wu( @@ -3188,7 +3188,7 @@ pub fn lasx_xvmaddwev_d_wu(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwev_w_hu(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwev_w_hu( @@ -3201,7 +3201,7 @@ pub fn lasx_xvmaddwev_w_hu(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwev_h_bu(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwev_h_bu( @@ -3214,7 +3214,7 @@ pub fn lasx_xvmaddwev_h_bu(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwod_q_d(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwod_q_d( @@ -3227,7 +3227,7 @@ pub fn lasx_xvmaddwod_q_d(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwod_d_w(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwod_d_w( @@ -3240,7 +3240,7 @@ pub fn lasx_xvmaddwod_d_w(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwod_w_h(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwod_w_h( @@ -3253,7 +3253,7 @@ pub fn lasx_xvmaddwod_w_h(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwod_h_b(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwod_h_b( @@ -3266,7 +3266,7 @@ pub fn lasx_xvmaddwod_h_b(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwod_q_du(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwod_q_du( @@ -3279,7 +3279,7 @@ pub fn lasx_xvmaddwod_q_du(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwod_d_wu(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwod_d_wu( @@ -3292,7 +3292,7 @@ pub fn lasx_xvmaddwod_d_wu(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwod_w_hu(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwod_w_hu( @@ -3305,7 +3305,7 @@ pub fn lasx_xvmaddwod_w_hu(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwod_h_bu(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwod_h_bu( @@ -3318,7 +3318,7 @@ pub fn lasx_xvmaddwod_h_bu(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwev_q_du_d(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwev_q_du_d( @@ -3331,7 +3331,7 @@ pub fn lasx_xvmaddwev_q_du_d(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwev_d_wu_w(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwev_d_wu_w( @@ -3344,7 +3344,7 @@ pub fn lasx_xvmaddwev_d_wu_w(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwev_w_hu_h(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwev_w_hu_h( @@ -3357,7 +3357,7 @@ pub fn lasx_xvmaddwev_w_hu_h(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwev_h_bu_b(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwev_h_bu_b( @@ -3370,7 +3370,7 @@ pub fn lasx_xvmaddwev_h_bu_b(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwod_q_du_d(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwod_q_du_d( @@ -3383,7 +3383,7 @@ pub fn lasx_xvmaddwod_q_du_d(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwod_d_wu_w(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwod_d_wu_w( @@ -3396,7 +3396,7 @@ pub fn lasx_xvmaddwod_d_wu_w(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwod_w_hu_h(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwod_w_hu_h( @@ -3409,7 +3409,7 @@ pub fn lasx_xvmaddwod_w_hu_h(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmaddwod_h_bu_b(a: m256i, b: m256i, c: m256i) -> m256i { unsafe { transmute(__lasx_xvmaddwod_h_bu_b( @@ -3422,126 +3422,126 @@ pub fn lasx_xvmaddwod_h_bu_b(a: m256i, b: m256i, c: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvadd_q(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvadd_q(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsub_q(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvsub_q(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwev_q_du_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwev_q_du_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvaddwod_q_du_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvaddwod_q_du_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwev_q_du_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwev_q_du_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmulwod_q_du_d(a: m256i, b: m256i) -> m256i { unsafe { transmute(__lasx_xvmulwod_q_du_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmskgez_b(a: m256i) -> m256i { unsafe { transmute(__lasx_xvmskgez_b(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvmsknz_b(a: m256i) -> m256i { unsafe { transmute(__lasx_xvmsknz_b(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvexth_h_b(a: m256i) -> m256i { unsafe { transmute(__lasx_xvexth_h_b(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvexth_w_h(a: m256i) -> m256i { unsafe { transmute(__lasx_xvexth_w_h(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvexth_d_w(a: m256i) -> m256i { unsafe { transmute(__lasx_xvexth_d_w(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvexth_q_d(a: m256i) -> m256i { unsafe { transmute(__lasx_xvexth_q_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvexth_hu_bu(a: m256i) -> m256i { unsafe { transmute(__lasx_xvexth_hu_bu(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvexth_wu_hu(a: m256i) -> m256i { unsafe { transmute(__lasx_xvexth_wu_hu(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvexth_du_wu(a: m256i) -> m256i { unsafe { transmute(__lasx_xvexth_du_wu(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvexth_qu_du(a: m256i) -> m256i { unsafe { transmute(__lasx_xvexth_qu_du(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvextl_q_d(a: m256i) -> m256i { unsafe { transmute(__lasx_xvextl_q_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrlni_b_h(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvsrlni_b_h(transmute(a), transmute(b), IMM4)) } @@ -3549,7 +3549,7 @@ pub fn lasx_xvsrlni_b_h(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrlni_h_w(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvsrlni_h_w(transmute(a), transmute(b), IMM5)) } @@ -3557,7 +3557,7 @@ pub fn lasx_xvsrlni_h_w(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrlni_w_d(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lasx_xvsrlni_w_d(transmute(a), transmute(b), IMM6)) } @@ -3565,7 +3565,7 @@ pub fn lasx_xvsrlni_w_d(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrlni_d_q(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lasx_xvsrlni_d_q(transmute(a), transmute(b), IMM7)) } @@ -3573,7 +3573,7 @@ pub fn lasx_xvsrlni_d_q(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrlrni_b_h(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvsrlrni_b_h(transmute(a), transmute(b), IMM4)) } @@ -3581,7 +3581,7 @@ pub fn lasx_xvsrlrni_b_h(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrlrni_h_w(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvsrlrni_h_w(transmute(a), transmute(b), IMM5)) } @@ -3589,7 +3589,7 @@ pub fn lasx_xvsrlrni_h_w(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrlrni_w_d(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lasx_xvsrlrni_w_d(transmute(a), transmute(b), IMM6)) } @@ -3597,7 +3597,7 @@ pub fn lasx_xvsrlrni_w_d(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrlrni_d_q(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lasx_xvsrlrni_d_q(transmute(a), transmute(b), IMM7)) } @@ -3605,7 +3605,7 @@ pub fn lasx_xvsrlrni_d_q(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlni_b_h(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvssrlni_b_h(transmute(a), transmute(b), IMM4)) } @@ -3613,7 +3613,7 @@ pub fn lasx_xvssrlni_b_h(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlni_h_w(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvssrlni_h_w(transmute(a), transmute(b), IMM5)) } @@ -3621,7 +3621,7 @@ pub fn lasx_xvssrlni_h_w(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlni_w_d(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lasx_xvssrlni_w_d(transmute(a), transmute(b), IMM6)) } @@ -3629,7 +3629,7 @@ pub fn lasx_xvssrlni_w_d(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlni_d_q(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lasx_xvssrlni_d_q(transmute(a), transmute(b), IMM7)) } @@ -3637,7 +3637,7 @@ pub fn lasx_xvssrlni_d_q(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlni_bu_h(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvssrlni_bu_h(transmute(a), transmute(b), IMM4)) } @@ -3645,7 +3645,7 @@ pub fn lasx_xvssrlni_bu_h(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlni_hu_w(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvssrlni_hu_w(transmute(a), transmute(b), IMM5)) } @@ -3653,7 +3653,7 @@ pub fn lasx_xvssrlni_hu_w(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlni_wu_d(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lasx_xvssrlni_wu_d(transmute(a), transmute(b), IMM6)) } @@ -3661,7 +3661,7 @@ pub fn lasx_xvssrlni_wu_d(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlni_du_q(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lasx_xvssrlni_du_q(transmute(a), transmute(b), IMM7)) } @@ -3669,7 +3669,7 @@ pub fn lasx_xvssrlni_du_q(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlrni_b_h(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvssrlrni_b_h(transmute(a), transmute(b), IMM4)) } @@ -3677,7 +3677,7 @@ pub fn lasx_xvssrlrni_b_h(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlrni_h_w(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvssrlrni_h_w(transmute(a), transmute(b), IMM5)) } @@ -3685,7 +3685,7 @@ pub fn lasx_xvssrlrni_h_w(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlrni_w_d(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lasx_xvssrlrni_w_d(transmute(a), transmute(b), IMM6)) } @@ -3693,7 +3693,7 @@ pub fn lasx_xvssrlrni_w_d(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlrni_d_q(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lasx_xvssrlrni_d_q(transmute(a), transmute(b), IMM7)) } @@ -3701,7 +3701,7 @@ pub fn lasx_xvssrlrni_d_q(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlrni_bu_h(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvssrlrni_bu_h(transmute(a), transmute(b), IMM4)) } @@ -3709,7 +3709,7 @@ pub fn lasx_xvssrlrni_bu_h(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlrni_hu_w(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvssrlrni_hu_w(transmute(a), transmute(b), IMM5)) } @@ -3717,7 +3717,7 @@ pub fn lasx_xvssrlrni_hu_w(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlrni_wu_d(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lasx_xvssrlrni_wu_d(transmute(a), transmute(b), IMM6)) } @@ -3725,7 +3725,7 @@ pub fn lasx_xvssrlrni_wu_d(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrlrni_du_q(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lasx_xvssrlrni_du_q(transmute(a), transmute(b), IMM7)) } @@ -3733,7 +3733,7 @@ pub fn lasx_xvssrlrni_du_q(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrani_b_h(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvsrani_b_h(transmute(a), transmute(b), IMM4)) } @@ -3741,7 +3741,7 @@ pub fn lasx_xvsrani_b_h(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrani_h_w(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvsrani_h_w(transmute(a), transmute(b), IMM5)) } @@ -3749,7 +3749,7 @@ pub fn lasx_xvsrani_h_w(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrani_w_d(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lasx_xvsrani_w_d(transmute(a), transmute(b), IMM6)) } @@ -3757,7 +3757,7 @@ pub fn lasx_xvsrani_w_d(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrani_d_q(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lasx_xvsrani_d_q(transmute(a), transmute(b), IMM7)) } @@ -3765,7 +3765,7 @@ pub fn lasx_xvsrani_d_q(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrarni_b_h(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvsrarni_b_h(transmute(a), transmute(b), IMM4)) } @@ -3773,7 +3773,7 @@ pub fn lasx_xvsrarni_b_h(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrarni_h_w(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvsrarni_h_w(transmute(a), transmute(b), IMM5)) } @@ -3781,7 +3781,7 @@ pub fn lasx_xvsrarni_h_w(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrarni_w_d(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lasx_xvsrarni_w_d(transmute(a), transmute(b), IMM6)) } @@ -3789,7 +3789,7 @@ pub fn lasx_xvsrarni_w_d(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvsrarni_d_q(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lasx_xvsrarni_d_q(transmute(a), transmute(b), IMM7)) } @@ -3797,7 +3797,7 @@ pub fn lasx_xvsrarni_d_q(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrani_b_h(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvssrani_b_h(transmute(a), transmute(b), IMM4)) } @@ -3805,7 +3805,7 @@ pub fn lasx_xvssrani_b_h(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrani_h_w(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvssrani_h_w(transmute(a), transmute(b), IMM5)) } @@ -3813,7 +3813,7 @@ pub fn lasx_xvssrani_h_w(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrani_w_d(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lasx_xvssrani_w_d(transmute(a), transmute(b), IMM6)) } @@ -3821,7 +3821,7 @@ pub fn lasx_xvssrani_w_d(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrani_d_q(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lasx_xvssrani_d_q(transmute(a), transmute(b), IMM7)) } @@ -3829,7 +3829,7 @@ pub fn lasx_xvssrani_d_q(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrani_bu_h(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvssrani_bu_h(transmute(a), transmute(b), IMM4)) } @@ -3837,7 +3837,7 @@ pub fn lasx_xvssrani_bu_h(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrani_hu_w(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvssrani_hu_w(transmute(a), transmute(b), IMM5)) } @@ -3845,7 +3845,7 @@ pub fn lasx_xvssrani_hu_w(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrani_wu_d(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lasx_xvssrani_wu_d(transmute(a), transmute(b), IMM6)) } @@ -3853,7 +3853,7 @@ pub fn lasx_xvssrani_wu_d(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrani_du_q(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lasx_xvssrani_du_q(transmute(a), transmute(b), IMM7)) } @@ -3861,7 +3861,7 @@ pub fn lasx_xvssrani_du_q(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrarni_b_h(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvssrarni_b_h(transmute(a), transmute(b), IMM4)) } @@ -3869,7 +3869,7 @@ pub fn lasx_xvssrarni_b_h(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrarni_h_w(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvssrarni_h_w(transmute(a), transmute(b), IMM5)) } @@ -3877,7 +3877,7 @@ pub fn lasx_xvssrarni_h_w(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrarni_w_d(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lasx_xvssrarni_w_d(transmute(a), transmute(b), IMM6)) } @@ -3885,7 +3885,7 @@ pub fn lasx_xvssrarni_w_d(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrarni_d_q(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lasx_xvssrarni_d_q(transmute(a), transmute(b), IMM7)) } @@ -3893,7 +3893,7 @@ pub fn lasx_xvssrarni_d_q(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrarni_bu_h(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lasx_xvssrarni_bu_h(transmute(a), transmute(b), IMM4)) } @@ -3901,7 +3901,7 @@ pub fn lasx_xvssrarni_bu_h(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrarni_hu_w(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lasx_xvssrarni_hu_w(transmute(a), transmute(b), IMM5)) } @@ -3909,7 +3909,7 @@ pub fn lasx_xvssrarni_hu_w(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrarni_wu_d(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lasx_xvssrarni_wu_d(transmute(a), transmute(b), IMM6)) } @@ -3917,7 +3917,7 @@ pub fn lasx_xvssrarni_wu_d(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvssrarni_du_q(a: m256i, b: m256i) -> m256i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lasx_xvssrarni_du_q(transmute(a), transmute(b), IMM7)) } @@ -3925,385 +3925,385 @@ pub fn lasx_xvssrarni_du_q(a: m256i, b: m256i) -> m256i { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xbnz_b(a: m256i) -> i32 { unsafe { transmute(__lasx_xbnz_b(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xbnz_d(a: m256i) -> i32 { unsafe { transmute(__lasx_xbnz_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xbnz_h(a: m256i) -> i32 { unsafe { transmute(__lasx_xbnz_h(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xbnz_v(a: m256i) -> i32 { unsafe { transmute(__lasx_xbnz_v(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xbnz_w(a: m256i) -> i32 { unsafe { transmute(__lasx_xbnz_w(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xbz_b(a: m256i) -> i32 { unsafe { transmute(__lasx_xbz_b(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xbz_d(a: m256i) -> i32 { unsafe { transmute(__lasx_xbz_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xbz_h(a: m256i) -> i32 { unsafe { transmute(__lasx_xbz_h(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xbz_v(a: m256i) -> i32 { unsafe { transmute(__lasx_xbz_v(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xbz_w(a: m256i) -> i32 { unsafe { transmute(__lasx_xbz_w(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_caf_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_caf_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_caf_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_caf_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_ceq_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_ceq_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_ceq_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_ceq_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_cle_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_cle_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_cle_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_cle_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_clt_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_clt_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_clt_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_clt_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_cne_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_cne_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_cne_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_cne_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_cor_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_cor_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_cor_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_cor_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_cueq_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_cueq_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_cueq_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_cueq_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_cule_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_cule_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_cule_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_cule_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_cult_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_cult_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_cult_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_cult_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_cun_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_cun_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_cune_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_cune_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_cune_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_cune_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_cun_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_cun_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_saf_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_saf_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_saf_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_saf_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_seq_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_seq_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_seq_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_seq_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_sle_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_sle_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_sle_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_sle_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_slt_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_slt_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_slt_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_slt_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_sne_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_sne_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_sne_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_sne_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_sor_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_sor_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_sor_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_sor_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_sueq_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_sueq_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_sueq_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_sueq_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_sule_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_sule_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_sule_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_sule_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_sult_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_sult_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_sult_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_sult_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_sun_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_sun_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_sune_d(a: m256d, b: m256d) -> m256i { unsafe { transmute(__lasx_xvfcmp_sune_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_sune_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_sune_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvfcmp_sun_s(a: m256, b: m256) -> m256i { unsafe { transmute(__lasx_xvfcmp_sun_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvpickve_d_f(a: m256d) -> m256d { static_assert_uimm_bits!(IMM2, 2); unsafe { transmute(__lasx_xvpickve_d_f(transmute(a), IMM2)) } @@ -4311,7 +4311,7 @@ pub fn lasx_xvpickve_d_f(a: m256d) -> m256d { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_xvpickve_w_f(a: m256) -> m256 { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lasx_xvpickve_w_f(transmute(a), IMM3)) } @@ -4319,126 +4319,126 @@ pub fn lasx_xvpickve_w_f(a: m256) -> m256 { #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_cast_128_s(a: m128) -> m256 { unsafe { transmute(__lasx_cast_128_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_cast_128_d(a: m128d) -> m256d { unsafe { transmute(__lasx_cast_128_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_cast_128(a: m128i) -> m256i { unsafe { transmute(__lasx_cast_128(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_concat_128_s(a: m128, b: m128) -> m256 { unsafe { transmute(__lasx_concat_128_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_concat_128_d(a: m128d, b: m128d) -> m256d { unsafe { transmute(__lasx_concat_128_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_concat_128(a: m128i, b: m128i) -> m256i { unsafe { transmute(__lasx_concat_128(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_extract_128_lo_s(a: m256) -> m128 { unsafe { transmute(__lasx_extract_128_lo_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_extract_128_hi_s(a: m256) -> m128 { unsafe { transmute(__lasx_extract_128_hi_s(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_extract_128_lo_d(a: m256d) -> m128d { unsafe { transmute(__lasx_extract_128_lo_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_extract_128_hi_d(a: m256d) -> m128d { unsafe { transmute(__lasx_extract_128_hi_d(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_extract_128_lo(a: m256i) -> m128i { unsafe { transmute(__lasx_extract_128_lo(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_extract_128_hi(a: m256i) -> m128i { unsafe { transmute(__lasx_extract_128_hi(transmute(a))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_insert_128_lo_s(a: m256, b: m128) -> m256 { unsafe { transmute(__lasx_insert_128_lo_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_insert_128_hi_s(a: m256, b: m128) -> m256 { unsafe { transmute(__lasx_insert_128_hi_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_insert_128_lo_d(a: m256d, b: m128d) -> m256d { unsafe { transmute(__lasx_insert_128_lo_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_insert_128_hi_d(a: m256d, b: m128d) -> m256d { unsafe { transmute(__lasx_insert_128_hi_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_insert_128_lo(a: m256i, b: m128i) -> m256i { unsafe { transmute(__lasx_insert_128_lo(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lasx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lasx_insert_128_hi(a: m256i, b: m128i) -> m256i { unsafe { transmute(__lasx_insert_128_hi(transmute(a), transmute(b))) } } diff --git a/library/stdarch/crates/core_arch/src/loongarch64/lasx/mod.rs b/library/stdarch/crates/core_arch/src/loongarch64/lasx/mod.rs index 22cdfa025b5d8..e0d58e21a056d 100644 --- a/library/stdarch/crates/core_arch/src/loongarch64/lasx/mod.rs +++ b/library/stdarch/crates/core_arch/src/loongarch64/lasx/mod.rs @@ -6,21 +6,21 @@ mod types; #[rustfmt::skip] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub use self::types::*; #[rustfmt::skip] mod generated; #[rustfmt::skip] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub use self::generated::*; #[rustfmt::skip] mod portable; #[rustfmt::skip] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub use self::portable::*; #[rustfmt::skip] diff --git a/library/stdarch/crates/core_arch/src/loongarch64/lasx/types.rs b/library/stdarch/crates/core_arch/src/loongarch64/lasx/types.rs index 5bbf113c63097..5e287489def03 100644 --- a/library/stdarch/crates/core_arch/src/loongarch64/lasx/types.rs +++ b/library/stdarch/crates/core_arch/src/loongarch64/lasx/types.rs @@ -1,5 +1,5 @@ types! { - #![stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #![stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] /// 256-bit wide integer vector type, LoongArch-specific /// diff --git a/library/stdarch/crates/core_arch/src/loongarch64/lsx/generated.rs b/library/stdarch/crates/core_arch/src/loongarch64/lsx/generated.rs index d2d065abf665a..cd581ac5e18ab 100644 --- a/library/stdarch/crates/core_arch/src/loongarch64/lsx/generated.rs +++ b/library/stdarch/crates/core_arch/src/loongarch64/lsx/generated.rs @@ -861,35 +861,35 @@ unsafe extern "llvm-intrinsic" { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrar_b(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsrar_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrar_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsrar_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrar_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsrar_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrar_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsrar_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrari_b(a: m128i) -> m128i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lsx_vsrari_b(transmute(a), IMM3)) } @@ -897,7 +897,7 @@ pub fn lsx_vsrari_b(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrari_h(a: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vsrari_h(transmute(a), IMM4)) } @@ -905,7 +905,7 @@ pub fn lsx_vsrari_h(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrari_w(a: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vsrari_w(transmute(a), IMM5)) } @@ -913,7 +913,7 @@ pub fn lsx_vsrari_w(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrari_d(a: m128i) -> m128i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lsx_vsrari_d(transmute(a), IMM6)) } @@ -921,35 +921,35 @@ pub fn lsx_vsrari_d(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrlr_b(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsrlr_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrlr_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsrlr_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrlr_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsrlr_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrlr_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsrlr_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrlri_b(a: m128i) -> m128i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lsx_vsrlri_b(transmute(a), IMM3)) } @@ -957,7 +957,7 @@ pub fn lsx_vsrlri_b(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrlri_h(a: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vsrlri_h(transmute(a), IMM4)) } @@ -965,7 +965,7 @@ pub fn lsx_vsrlri_h(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrlri_w(a: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vsrlri_w(transmute(a), IMM5)) } @@ -973,7 +973,7 @@ pub fn lsx_vsrlri_w(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrlri_d(a: m128i) -> m128i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lsx_vsrlri_d(transmute(a), IMM6)) } @@ -981,7 +981,7 @@ pub fn lsx_vsrlri_d(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vbitclri_b(a: m128i) -> m128i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lsx_vbitclri_b(transmute(a), IMM3)) } @@ -989,7 +989,7 @@ pub fn lsx_vbitclri_b(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vbitclri_h(a: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vbitclri_h(transmute(a), IMM4)) } @@ -997,7 +997,7 @@ pub fn lsx_vbitclri_h(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vbitclri_w(a: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vbitclri_w(transmute(a), IMM5)) } @@ -1005,7 +1005,7 @@ pub fn lsx_vbitclri_w(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vbitclri_d(a: m128i) -> m128i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lsx_vbitclri_d(transmute(a), IMM6)) } @@ -1013,7 +1013,7 @@ pub fn lsx_vbitclri_d(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vbitseti_b(a: m128i) -> m128i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lsx_vbitseti_b(transmute(a), IMM3)) } @@ -1021,7 +1021,7 @@ pub fn lsx_vbitseti_b(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vbitseti_h(a: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vbitseti_h(transmute(a), IMM4)) } @@ -1029,7 +1029,7 @@ pub fn lsx_vbitseti_h(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vbitseti_w(a: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vbitseti_w(transmute(a), IMM5)) } @@ -1037,7 +1037,7 @@ pub fn lsx_vbitseti_w(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vbitseti_d(a: m128i) -> m128i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lsx_vbitseti_d(transmute(a), IMM6)) } @@ -1045,7 +1045,7 @@ pub fn lsx_vbitseti_d(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vbitrevi_b(a: m128i) -> m128i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lsx_vbitrevi_b(transmute(a), IMM3)) } @@ -1053,7 +1053,7 @@ pub fn lsx_vbitrevi_b(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vbitrevi_h(a: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vbitrevi_h(transmute(a), IMM4)) } @@ -1061,7 +1061,7 @@ pub fn lsx_vbitrevi_h(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vbitrevi_w(a: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vbitrevi_w(transmute(a), IMM5)) } @@ -1069,7 +1069,7 @@ pub fn lsx_vbitrevi_w(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vbitrevi_d(a: m128i) -> m128i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lsx_vbitrevi_d(transmute(a), IMM6)) } @@ -1077,7 +1077,7 @@ pub fn lsx_vbitrevi_d(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubi_bu(a: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vsubi_bu(transmute(a), IMM5)) } @@ -1085,7 +1085,7 @@ pub fn lsx_vsubi_bu(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubi_hu(a: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vsubi_hu(transmute(a), IMM5)) } @@ -1093,7 +1093,7 @@ pub fn lsx_vsubi_hu(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubi_wu(a: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vsubi_wu(transmute(a), IMM5)) } @@ -1101,7 +1101,7 @@ pub fn lsx_vsubi_wu(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubi_du(a: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vsubi_du(transmute(a), IMM5)) } @@ -1109,7 +1109,7 @@ pub fn lsx_vsubi_du(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsat_b(a: m128i) -> m128i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lsx_vsat_b(transmute(a), IMM3)) } @@ -1117,7 +1117,7 @@ pub fn lsx_vsat_b(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsat_h(a: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vsat_h(transmute(a), IMM4)) } @@ -1125,7 +1125,7 @@ pub fn lsx_vsat_h(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsat_w(a: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vsat_w(transmute(a), IMM5)) } @@ -1133,7 +1133,7 @@ pub fn lsx_vsat_w(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsat_d(a: m128i) -> m128i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lsx_vsat_d(transmute(a), IMM6)) } @@ -1141,7 +1141,7 @@ pub fn lsx_vsat_d(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsat_bu(a: m128i) -> m128i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lsx_vsat_bu(transmute(a), IMM3)) } @@ -1149,7 +1149,7 @@ pub fn lsx_vsat_bu(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsat_hu(a: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vsat_hu(transmute(a), IMM4)) } @@ -1157,7 +1157,7 @@ pub fn lsx_vsat_hu(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsat_wu(a: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vsat_wu(transmute(a), IMM5)) } @@ -1165,7 +1165,7 @@ pub fn lsx_vsat_wu(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsat_du(a: m128i) -> m128i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lsx_vsat_du(transmute(a), IMM6)) } @@ -1173,252 +1173,252 @@ pub fn lsx_vsat_du(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vdiv_b(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vdiv_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vdiv_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vdiv_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vdiv_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vdiv_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vdiv_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vdiv_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vdiv_bu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vdiv_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vdiv_hu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vdiv_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vdiv_wu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vdiv_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vdiv_du(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vdiv_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vhaddw_h_b(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vhaddw_h_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vhaddw_w_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vhaddw_w_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vhaddw_d_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vhaddw_d_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vhaddw_hu_bu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vhaddw_hu_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vhaddw_wu_hu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vhaddw_wu_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vhaddw_du_wu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vhaddw_du_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vhsubw_h_b(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vhsubw_h_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vhsubw_w_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vhsubw_w_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vhsubw_d_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vhsubw_d_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vhsubw_hu_bu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vhsubw_hu_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vhsubw_wu_hu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vhsubw_wu_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vhsubw_du_wu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vhsubw_du_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmod_b(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmod_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmod_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmod_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmod_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmod_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmod_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmod_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmod_bu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmod_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmod_hu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmod_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmod_wu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmod_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmod_du(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmod_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vreplve_b(a: m128i, b: i32) -> m128i { unsafe { transmute(__lsx_vreplve_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vreplve_h(a: m128i, b: i32) -> m128i { unsafe { transmute(__lsx_vreplve_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vreplve_w(a: m128i, b: i32) -> m128i { unsafe { transmute(__lsx_vreplve_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vreplve_d(a: m128i, b: i32) -> m128i { unsafe { transmute(__lsx_vreplve_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vshuf_h(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vshuf_h(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vshuf_w(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vshuf_w(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vshuf_d(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vshuf_d(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vandi_b(a: m128i) -> m128i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lsx_vandi_b(transmute(a), IMM8)) } @@ -1426,7 +1426,7 @@ pub fn lsx_vandi_b(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vori_b(a: m128i) -> m128i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lsx_vori_b(transmute(a), IMM8)) } @@ -1434,7 +1434,7 @@ pub fn lsx_vori_b(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vnori_b(a: m128i) -> m128i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lsx_vnori_b(transmute(a), IMM8)) } @@ -1442,7 +1442,7 @@ pub fn lsx_vnori_b(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vxori_b(a: m128i) -> m128i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lsx_vxori_b(transmute(a), IMM8)) } @@ -1450,14 +1450,14 @@ pub fn lsx_vxori_b(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vbitsel_v(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vbitsel_v(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vbitseli_b(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lsx_vbitseli_b(transmute(a), transmute(b), IMM8)) } @@ -1465,287 +1465,287 @@ pub fn lsx_vbitseli_b(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vclo_b(a: m128i) -> m128i { unsafe { transmute(__lsx_vclo_b(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vclo_h(a: m128i) -> m128i { unsafe { transmute(__lsx_vclo_h(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vclo_w(a: m128i) -> m128i { unsafe { transmute(__lsx_vclo_w(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vclo_d(a: m128i) -> m128i { unsafe { transmute(__lsx_vclo_d(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcvt_h_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcvt_h_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcvt_s_d(a: m128d, b: m128d) -> m128 { unsafe { transmute(__lsx_vfcvt_s_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfmin_s(a: m128, b: m128) -> m128 { unsafe { transmute(__lsx_vfmin_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfmin_d(a: m128d, b: m128d) -> m128d { unsafe { transmute(__lsx_vfmin_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfmina_s(a: m128, b: m128) -> m128 { unsafe { transmute(__lsx_vfmina_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfmina_d(a: m128d, b: m128d) -> m128d { unsafe { transmute(__lsx_vfmina_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfmax_s(a: m128, b: m128) -> m128 { unsafe { transmute(__lsx_vfmax_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfmax_d(a: m128d, b: m128d) -> m128d { unsafe { transmute(__lsx_vfmax_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfmaxa_s(a: m128, b: m128) -> m128 { unsafe { transmute(__lsx_vfmaxa_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfmaxa_d(a: m128d, b: m128d) -> m128d { unsafe { transmute(__lsx_vfmaxa_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfclass_s(a: m128) -> m128i { unsafe { transmute(__lsx_vfclass_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfclass_d(a: m128d) -> m128i { unsafe { transmute(__lsx_vfclass_d(transmute(a))) } } #[inline] #[target_feature(enable = "lsx,frecipe")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfrecipe_s(a: m128) -> m128 { unsafe { transmute(__lsx_vfrecipe_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx,frecipe")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfrecipe_d(a: m128d) -> m128d { unsafe { transmute(__lsx_vfrecipe_d(transmute(a))) } } #[inline] #[target_feature(enable = "lsx,frecipe")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfrsqrte_s(a: m128) -> m128 { unsafe { transmute(__lsx_vfrsqrte_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx,frecipe")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfrsqrte_d(a: m128d) -> m128d { unsafe { transmute(__lsx_vfrsqrte_d(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfrint_s(a: m128) -> m128 { unsafe { transmute(__lsx_vfrint_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfrint_d(a: m128d) -> m128d { unsafe { transmute(__lsx_vfrint_d(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vflogb_s(a: m128) -> m128 { unsafe { transmute(__lsx_vflogb_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vflogb_d(a: m128d) -> m128d { unsafe { transmute(__lsx_vflogb_d(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcvth_s_h(a: m128i) -> m128 { unsafe { transmute(__lsx_vfcvth_s_h(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcvth_d_s(a: m128) -> m128d { unsafe { transmute(__lsx_vfcvth_d_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcvtl_s_h(a: m128i) -> m128 { unsafe { transmute(__lsx_vfcvtl_s_h(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcvtl_d_s(a: m128) -> m128d { unsafe { transmute(__lsx_vfcvtl_d_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftint_w_s(a: m128) -> m128i { unsafe { transmute(__lsx_vftint_w_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftint_l_d(a: m128d) -> m128i { unsafe { transmute(__lsx_vftint_l_d(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftint_wu_s(a: m128) -> m128i { unsafe { transmute(__lsx_vftint_wu_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftint_lu_d(a: m128d) -> m128i { unsafe { transmute(__lsx_vftint_lu_d(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrz_w_s(a: m128) -> m128i { unsafe { transmute(__lsx_vftintrz_w_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrz_l_d(a: m128d) -> m128i { unsafe { transmute(__lsx_vftintrz_l_d(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrz_wu_s(a: m128) -> m128i { unsafe { transmute(__lsx_vftintrz_wu_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrz_lu_d(a: m128d) -> m128i { unsafe { transmute(__lsx_vftintrz_lu_d(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vffint_s_w(a: m128i) -> m128 { unsafe { transmute(__lsx_vffint_s_w(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vffint_d_l(a: m128i) -> m128d { unsafe { transmute(__lsx_vffint_d_l(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vffint_s_wu(a: m128i) -> m128 { unsafe { transmute(__lsx_vffint_s_wu(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vffint_d_lu(a: m128i) -> m128d { unsafe { transmute(__lsx_vffint_d_lu(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsllwil_h_b(a: m128i) -> m128i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lsx_vsllwil_h_b(transmute(a), IMM3)) } @@ -1753,7 +1753,7 @@ pub fn lsx_vsllwil_h_b(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsllwil_w_h(a: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vsllwil_w_h(transmute(a), IMM4)) } @@ -1761,7 +1761,7 @@ pub fn lsx_vsllwil_w_h(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsllwil_d_w(a: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vsllwil_d_w(transmute(a), IMM5)) } @@ -1769,7 +1769,7 @@ pub fn lsx_vsllwil_d_w(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsllwil_hu_bu(a: m128i) -> m128i { static_assert_uimm_bits!(IMM3, 3); unsafe { transmute(__lsx_vsllwil_hu_bu(transmute(a), IMM3)) } @@ -1777,7 +1777,7 @@ pub fn lsx_vsllwil_hu_bu(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsllwil_wu_hu(a: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vsllwil_wu_hu(transmute(a), IMM4)) } @@ -1785,7 +1785,7 @@ pub fn lsx_vsllwil_wu_hu(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsllwil_du_wu(a: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vsllwil_du_wu(transmute(a), IMM5)) } @@ -1793,217 +1793,217 @@ pub fn lsx_vsllwil_du_wu(a: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsran_b_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsran_b_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsran_h_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsran_h_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsran_w_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsran_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssran_b_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssran_b_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssran_h_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssran_h_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssran_w_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssran_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssran_bu_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssran_bu_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssran_hu_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssran_hu_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssran_wu_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssran_wu_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrarn_b_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsrarn_b_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrarn_h_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsrarn_h_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrarn_w_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsrarn_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrarn_b_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssrarn_b_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrarn_h_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssrarn_h_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrarn_w_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssrarn_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrarn_bu_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssrarn_bu_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrarn_hu_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssrarn_hu_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrarn_wu_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssrarn_wu_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrln_b_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsrln_b_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrln_h_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsrln_h_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrln_w_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsrln_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrln_bu_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssrln_bu_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrln_hu_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssrln_hu_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrln_wu_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssrln_wu_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrlrn_b_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsrlrn_b_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrlrn_h_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsrlrn_h_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrlrn_w_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsrlrn_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlrn_bu_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssrlrn_bu_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlrn_hu_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssrlrn_hu_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlrn_wu_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssrlrn_wu_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfrstpi_b(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vfrstpi_b(transmute(a), transmute(b), IMM5)) } @@ -2011,7 +2011,7 @@ pub fn lsx_vfrstpi_b(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfrstpi_h(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vfrstpi_h(transmute(a), transmute(b), IMM5)) } @@ -2019,21 +2019,21 @@ pub fn lsx_vfrstpi_h(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfrstp_b(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vfrstp_b(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfrstp_h(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vfrstp_h(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vextrins_b(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lsx_vextrins_b(transmute(a), transmute(b), IMM8)) } @@ -2041,7 +2041,7 @@ pub fn lsx_vextrins_b(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vextrins_h(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lsx_vextrins_h(transmute(a), transmute(b), IMM8)) } @@ -2049,7 +2049,7 @@ pub fn lsx_vextrins_h(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vextrins_w(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lsx_vextrins_w(transmute(a), transmute(b), IMM8)) } @@ -2057,7 +2057,7 @@ pub fn lsx_vextrins_w(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vextrins_d(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lsx_vextrins_d(transmute(a), transmute(b), IMM8)) } @@ -2065,245 +2065,245 @@ pub fn lsx_vextrins_d(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmskltz_b(a: m128i) -> m128i { unsafe { transmute(__lsx_vmskltz_b(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmskltz_h(a: m128i) -> m128i { unsafe { transmute(__lsx_vmskltz_h(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmskltz_w(a: m128i) -> m128i { unsafe { transmute(__lsx_vmskltz_w(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmskltz_d(a: m128i) -> m128i { unsafe { transmute(__lsx_vmskltz_d(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsigncov_b(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsigncov_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsigncov_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsigncov_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsigncov_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsigncov_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsigncov_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsigncov_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrne_w_s(a: m128) -> m128i { unsafe { transmute(__lsx_vftintrne_w_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrne_l_d(a: m128d) -> m128i { unsafe { transmute(__lsx_vftintrne_l_d(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrp_w_s(a: m128) -> m128i { unsafe { transmute(__lsx_vftintrp_w_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrp_l_d(a: m128d) -> m128i { unsafe { transmute(__lsx_vftintrp_l_d(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrm_w_s(a: m128) -> m128i { unsafe { transmute(__lsx_vftintrm_w_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrm_l_d(a: m128d) -> m128i { unsafe { transmute(__lsx_vftintrm_l_d(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftint_w_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vftint_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vffint_s_l(a: m128i, b: m128i) -> m128 { unsafe { transmute(__lsx_vffint_s_l(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrz_w_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vftintrz_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrp_w_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vftintrp_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrm_w_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vftintrm_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrne_w_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vftintrne_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintl_l_s(a: m128) -> m128i { unsafe { transmute(__lsx_vftintl_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftinth_l_s(a: m128) -> m128i { unsafe { transmute(__lsx_vftinth_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vffinth_d_w(a: m128i) -> m128d { unsafe { transmute(__lsx_vffinth_d_w(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vffintl_d_w(a: m128i) -> m128d { unsafe { transmute(__lsx_vffintl_d_w(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrzl_l_s(a: m128) -> m128i { unsafe { transmute(__lsx_vftintrzl_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrzh_l_s(a: m128) -> m128i { unsafe { transmute(__lsx_vftintrzh_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrpl_l_s(a: m128) -> m128i { unsafe { transmute(__lsx_vftintrpl_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrph_l_s(a: m128) -> m128i { unsafe { transmute(__lsx_vftintrph_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrml_l_s(a: m128) -> m128i { unsafe { transmute(__lsx_vftintrml_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrmh_l_s(a: m128) -> m128i { unsafe { transmute(__lsx_vftintrmh_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrnel_l_s(a: m128) -> m128i { unsafe { transmute(__lsx_vftintrnel_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vftintrneh_l_s(a: m128) -> m128i { unsafe { transmute(__lsx_vftintrneh_l_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfrintrne_s(a: m128) -> m128 { unsafe { transmute(__lsx_vfrintrne_s(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfrintrne_d(a: m128d) -> m128d { unsafe { transmute(__lsx_vfrintrne_d(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn lsx_vstelm_b(a: m128i, mem_addr: *mut i8) { static_assert_simm_bits!(IMM_S8, 8); static_assert_uimm_bits!(IMM4, 4); @@ -2312,7 +2312,7 @@ pub unsafe fn lsx_vstelm_b(a: m128i, mem_add #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn lsx_vstelm_h(a: m128i, mem_addr: *mut i8) { static_assert_simm_bits!(IMM_S8, 8); static_assert_uimm_bits!(IMM3, 3); @@ -2321,7 +2321,7 @@ pub unsafe fn lsx_vstelm_h(a: m128i, mem_add #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn lsx_vstelm_w(a: m128i, mem_addr: *mut i8) { static_assert_simm_bits!(IMM_S8, 8); static_assert_uimm_bits!(IMM2, 2); @@ -2330,7 +2330,7 @@ pub unsafe fn lsx_vstelm_w(a: m128i, mem_add #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn lsx_vstelm_d(a: m128i, mem_addr: *mut i8) { static_assert_simm_bits!(IMM_S8, 8); static_assert_uimm_bits!(IMM1, 1); @@ -2339,504 +2339,504 @@ pub unsafe fn lsx_vstelm_d(a: m128i, mem_add #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwev_d_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwev_d_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwev_w_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwev_w_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwev_h_b(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwev_h_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwod_d_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwod_d_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwod_w_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwod_w_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwod_h_b(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwod_h_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwev_d_wu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwev_d_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwev_w_hu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwev_w_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwev_h_bu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwev_h_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwod_d_wu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwod_d_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwod_w_hu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwod_w_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwod_h_bu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwod_h_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwev_d_wu_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwev_d_wu_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwev_w_hu_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwev_w_hu_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwev_h_bu_b(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwev_h_bu_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwod_d_wu_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwod_d_wu_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwod_w_hu_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwod_w_hu_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwod_h_bu_b(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwod_h_bu_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubwev_d_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsubwev_d_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubwev_w_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsubwev_w_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubwev_h_b(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsubwev_h_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubwod_d_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsubwod_d_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubwod_w_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsubwod_w_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubwod_h_b(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsubwod_h_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubwev_d_wu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsubwev_d_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubwev_w_hu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsubwev_w_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubwev_h_bu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsubwev_h_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubwod_d_wu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsubwod_d_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubwod_w_hu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsubwod_w_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubwod_h_bu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsubwod_h_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwev_q_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwev_q_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwod_q_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwod_q_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwev_q_du(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwev_q_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwod_q_du(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwod_q_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubwev_q_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsubwev_q_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubwod_q_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsubwod_q_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubwev_q_du(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsubwev_q_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsubwod_q_du(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsubwod_q_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwev_q_du_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwev_q_du_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vaddwod_q_du_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vaddwod_q_du_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwev_d_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwev_d_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwev_w_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwev_w_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwev_h_b(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwev_h_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwod_d_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwod_d_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwod_w_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwod_w_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwod_h_b(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwod_h_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwev_d_wu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwev_d_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwev_w_hu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwev_w_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwev_h_bu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwev_h_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwod_d_wu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwod_d_wu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwod_w_hu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwod_w_hu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwod_h_bu(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwod_h_bu(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwev_d_wu_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwev_d_wu_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwev_w_hu_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwev_w_hu_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwev_h_bu_b(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwev_h_bu_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwod_d_wu_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwod_d_wu_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwod_w_hu_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwod_w_hu_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwod_h_bu_b(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwod_h_bu_b(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwev_q_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwev_q_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwod_q_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwod_q_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwev_q_du(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwev_q_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwod_q_du(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwod_q_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwev_q_du_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwev_q_du_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmulwod_q_du_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vmulwod_q_du_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vhaddw_q_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vhaddw_q_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vhaddw_qu_du(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vhaddw_qu_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vhsubw_q_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vhsubw_q_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vhsubw_qu_du(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vhsubw_qu_du(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwev_d_w(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwev_d_w(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwev_w_h(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwev_w_h(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwev_h_b(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwev_h_b(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwev_d_wu(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwev_d_wu( @@ -2849,7 +2849,7 @@ pub fn lsx_vmaddwev_d_wu(a: m128i, b: m128i, c: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwev_w_hu(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwev_w_hu( @@ -2862,7 +2862,7 @@ pub fn lsx_vmaddwev_w_hu(a: m128i, b: m128i, c: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwev_h_bu(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwev_h_bu( @@ -2875,28 +2875,28 @@ pub fn lsx_vmaddwev_h_bu(a: m128i, b: m128i, c: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwod_d_w(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwod_d_w(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwod_w_h(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwod_w_h(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwod_h_b(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwod_h_b(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwod_d_wu(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwod_d_wu( @@ -2909,7 +2909,7 @@ pub fn lsx_vmaddwod_d_wu(a: m128i, b: m128i, c: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwod_w_hu(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwod_w_hu( @@ -2922,7 +2922,7 @@ pub fn lsx_vmaddwod_w_hu(a: m128i, b: m128i, c: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwod_h_bu(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwod_h_bu( @@ -2935,7 +2935,7 @@ pub fn lsx_vmaddwod_h_bu(a: m128i, b: m128i, c: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwev_d_wu_w(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwev_d_wu_w( @@ -2948,7 +2948,7 @@ pub fn lsx_vmaddwev_d_wu_w(a: m128i, b: m128i, c: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwev_w_hu_h(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwev_w_hu_h( @@ -2961,7 +2961,7 @@ pub fn lsx_vmaddwev_w_hu_h(a: m128i, b: m128i, c: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwev_h_bu_b(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwev_h_bu_b( @@ -2974,7 +2974,7 @@ pub fn lsx_vmaddwev_h_bu_b(a: m128i, b: m128i, c: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwod_d_wu_w(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwod_d_wu_w( @@ -2987,7 +2987,7 @@ pub fn lsx_vmaddwod_d_wu_w(a: m128i, b: m128i, c: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwod_w_hu_h(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwod_w_hu_h( @@ -3000,7 +3000,7 @@ pub fn lsx_vmaddwod_w_hu_h(a: m128i, b: m128i, c: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwod_h_bu_b(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwod_h_bu_b( @@ -3013,21 +3013,21 @@ pub fn lsx_vmaddwod_h_bu_b(a: m128i, b: m128i, c: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwev_q_d(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwev_q_d(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwod_q_d(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwod_q_d(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwev_q_du(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwev_q_du( @@ -3040,7 +3040,7 @@ pub fn lsx_vmaddwev_q_du(a: m128i, b: m128i, c: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwod_q_du(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwod_q_du( @@ -3053,7 +3053,7 @@ pub fn lsx_vmaddwod_q_du(a: m128i, b: m128i, c: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwev_q_du_d(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwev_q_du_d( @@ -3066,7 +3066,7 @@ pub fn lsx_vmaddwev_q_du_d(a: m128i, b: m128i, c: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmaddwod_q_du_d(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vmaddwod_q_du_d( @@ -3079,21 +3079,21 @@ pub fn lsx_vmaddwod_q_du_d(a: m128i, b: m128i, c: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vadd_q(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vadd_q(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsub_q(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vsub_q(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn lsx_vldrepl_b(mem_addr: *const i8) -> m128i { static_assert_simm_bits!(IMM_S12, 12); transmute(__lsx_vldrepl_b(mem_addr, IMM_S12)) @@ -3101,7 +3101,7 @@ pub unsafe fn lsx_vldrepl_b(mem_addr: *const i8) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn lsx_vldrepl_h(mem_addr: *const i8) -> m128i { static_assert_simm_bits!(IMM_S11, 11); transmute(__lsx_vldrepl_h(mem_addr, IMM_S11)) @@ -3109,7 +3109,7 @@ pub unsafe fn lsx_vldrepl_h(mem_addr: *const i8) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn lsx_vldrepl_w(mem_addr: *const i8) -> m128i { static_assert_simm_bits!(IMM_S10, 10); transmute(__lsx_vldrepl_w(mem_addr, IMM_S10)) @@ -3117,7 +3117,7 @@ pub unsafe fn lsx_vldrepl_w(mem_addr: *const i8) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn lsx_vldrepl_d(mem_addr: *const i8) -> m128i { static_assert_simm_bits!(IMM_S9, 9); transmute(__lsx_vldrepl_d(mem_addr, IMM_S9)) @@ -3125,84 +3125,84 @@ pub unsafe fn lsx_vldrepl_d(mem_addr: *const i8) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmskgez_b(a: m128i) -> m128i { unsafe { transmute(__lsx_vmskgez_b(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vmsknz_b(a: m128i) -> m128i { unsafe { transmute(__lsx_vmsknz_b(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vexth_h_b(a: m128i) -> m128i { unsafe { transmute(__lsx_vexth_h_b(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vexth_w_h(a: m128i) -> m128i { unsafe { transmute(__lsx_vexth_w_h(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vexth_d_w(a: m128i) -> m128i { unsafe { transmute(__lsx_vexth_d_w(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vexth_q_d(a: m128i) -> m128i { unsafe { transmute(__lsx_vexth_q_d(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vexth_hu_bu(a: m128i) -> m128i { unsafe { transmute(__lsx_vexth_hu_bu(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vexth_wu_hu(a: m128i) -> m128i { unsafe { transmute(__lsx_vexth_wu_hu(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vexth_du_wu(a: m128i) -> m128i { unsafe { transmute(__lsx_vexth_du_wu(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vexth_qu_du(a: m128i) -> m128i { unsafe { transmute(__lsx_vexth_qu_du(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vextl_q_d(a: m128i) -> m128i { unsafe { transmute(__lsx_vextl_q_d(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrlni_b_h(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vsrlni_b_h(transmute(a), transmute(b), IMM4)) } @@ -3210,7 +3210,7 @@ pub fn lsx_vsrlni_b_h(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrlni_h_w(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vsrlni_h_w(transmute(a), transmute(b), IMM5)) } @@ -3218,7 +3218,7 @@ pub fn lsx_vsrlni_h_w(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrlni_w_d(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lsx_vsrlni_w_d(transmute(a), transmute(b), IMM6)) } @@ -3226,7 +3226,7 @@ pub fn lsx_vsrlni_w_d(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrlni_d_q(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lsx_vsrlni_d_q(transmute(a), transmute(b), IMM7)) } @@ -3234,7 +3234,7 @@ pub fn lsx_vsrlni_d_q(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrlrni_b_h(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vsrlrni_b_h(transmute(a), transmute(b), IMM4)) } @@ -3242,7 +3242,7 @@ pub fn lsx_vsrlrni_b_h(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrlrni_h_w(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vsrlrni_h_w(transmute(a), transmute(b), IMM5)) } @@ -3250,7 +3250,7 @@ pub fn lsx_vsrlrni_h_w(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrlrni_w_d(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lsx_vsrlrni_w_d(transmute(a), transmute(b), IMM6)) } @@ -3258,7 +3258,7 @@ pub fn lsx_vsrlrni_w_d(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrlrni_d_q(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lsx_vsrlrni_d_q(transmute(a), transmute(b), IMM7)) } @@ -3266,7 +3266,7 @@ pub fn lsx_vsrlrni_d_q(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlni_b_h(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vssrlni_b_h(transmute(a), transmute(b), IMM4)) } @@ -3274,7 +3274,7 @@ pub fn lsx_vssrlni_b_h(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlni_h_w(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vssrlni_h_w(transmute(a), transmute(b), IMM5)) } @@ -3282,7 +3282,7 @@ pub fn lsx_vssrlni_h_w(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlni_w_d(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lsx_vssrlni_w_d(transmute(a), transmute(b), IMM6)) } @@ -3290,7 +3290,7 @@ pub fn lsx_vssrlni_w_d(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlni_d_q(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lsx_vssrlni_d_q(transmute(a), transmute(b), IMM7)) } @@ -3298,7 +3298,7 @@ pub fn lsx_vssrlni_d_q(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlni_bu_h(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vssrlni_bu_h(transmute(a), transmute(b), IMM4)) } @@ -3306,7 +3306,7 @@ pub fn lsx_vssrlni_bu_h(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlni_hu_w(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vssrlni_hu_w(transmute(a), transmute(b), IMM5)) } @@ -3314,7 +3314,7 @@ pub fn lsx_vssrlni_hu_w(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlni_wu_d(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lsx_vssrlni_wu_d(transmute(a), transmute(b), IMM6)) } @@ -3322,7 +3322,7 @@ pub fn lsx_vssrlni_wu_d(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlni_du_q(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lsx_vssrlni_du_q(transmute(a), transmute(b), IMM7)) } @@ -3330,7 +3330,7 @@ pub fn lsx_vssrlni_du_q(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlrni_b_h(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vssrlrni_b_h(transmute(a), transmute(b), IMM4)) } @@ -3338,7 +3338,7 @@ pub fn lsx_vssrlrni_b_h(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlrni_h_w(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vssrlrni_h_w(transmute(a), transmute(b), IMM5)) } @@ -3346,7 +3346,7 @@ pub fn lsx_vssrlrni_h_w(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlrni_w_d(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lsx_vssrlrni_w_d(transmute(a), transmute(b), IMM6)) } @@ -3354,7 +3354,7 @@ pub fn lsx_vssrlrni_w_d(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlrni_d_q(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lsx_vssrlrni_d_q(transmute(a), transmute(b), IMM7)) } @@ -3362,7 +3362,7 @@ pub fn lsx_vssrlrni_d_q(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlrni_bu_h(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vssrlrni_bu_h(transmute(a), transmute(b), IMM4)) } @@ -3370,7 +3370,7 @@ pub fn lsx_vssrlrni_bu_h(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlrni_hu_w(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vssrlrni_hu_w(transmute(a), transmute(b), IMM5)) } @@ -3378,7 +3378,7 @@ pub fn lsx_vssrlrni_hu_w(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlrni_wu_d(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lsx_vssrlrni_wu_d(transmute(a), transmute(b), IMM6)) } @@ -3386,7 +3386,7 @@ pub fn lsx_vssrlrni_wu_d(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlrni_du_q(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lsx_vssrlrni_du_q(transmute(a), transmute(b), IMM7)) } @@ -3394,7 +3394,7 @@ pub fn lsx_vssrlrni_du_q(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrani_b_h(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vsrani_b_h(transmute(a), transmute(b), IMM4)) } @@ -3402,7 +3402,7 @@ pub fn lsx_vsrani_b_h(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrani_h_w(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vsrani_h_w(transmute(a), transmute(b), IMM5)) } @@ -3410,7 +3410,7 @@ pub fn lsx_vsrani_h_w(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrani_w_d(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lsx_vsrani_w_d(transmute(a), transmute(b), IMM6)) } @@ -3418,7 +3418,7 @@ pub fn lsx_vsrani_w_d(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrani_d_q(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lsx_vsrani_d_q(transmute(a), transmute(b), IMM7)) } @@ -3426,7 +3426,7 @@ pub fn lsx_vsrani_d_q(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrarni_b_h(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vsrarni_b_h(transmute(a), transmute(b), IMM4)) } @@ -3434,7 +3434,7 @@ pub fn lsx_vsrarni_b_h(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrarni_h_w(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vsrarni_h_w(transmute(a), transmute(b), IMM5)) } @@ -3442,7 +3442,7 @@ pub fn lsx_vsrarni_h_w(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrarni_w_d(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lsx_vsrarni_w_d(transmute(a), transmute(b), IMM6)) } @@ -3450,7 +3450,7 @@ pub fn lsx_vsrarni_w_d(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vsrarni_d_q(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lsx_vsrarni_d_q(transmute(a), transmute(b), IMM7)) } @@ -3458,7 +3458,7 @@ pub fn lsx_vsrarni_d_q(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrani_b_h(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vssrani_b_h(transmute(a), transmute(b), IMM4)) } @@ -3466,7 +3466,7 @@ pub fn lsx_vssrani_b_h(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrani_h_w(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vssrani_h_w(transmute(a), transmute(b), IMM5)) } @@ -3474,7 +3474,7 @@ pub fn lsx_vssrani_h_w(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrani_w_d(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lsx_vssrani_w_d(transmute(a), transmute(b), IMM6)) } @@ -3482,7 +3482,7 @@ pub fn lsx_vssrani_w_d(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrani_d_q(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lsx_vssrani_d_q(transmute(a), transmute(b), IMM7)) } @@ -3490,7 +3490,7 @@ pub fn lsx_vssrani_d_q(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrani_bu_h(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vssrani_bu_h(transmute(a), transmute(b), IMM4)) } @@ -3498,7 +3498,7 @@ pub fn lsx_vssrani_bu_h(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrani_hu_w(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vssrani_hu_w(transmute(a), transmute(b), IMM5)) } @@ -3506,7 +3506,7 @@ pub fn lsx_vssrani_hu_w(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrani_wu_d(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lsx_vssrani_wu_d(transmute(a), transmute(b), IMM6)) } @@ -3514,7 +3514,7 @@ pub fn lsx_vssrani_wu_d(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrani_du_q(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lsx_vssrani_du_q(transmute(a), transmute(b), IMM7)) } @@ -3522,7 +3522,7 @@ pub fn lsx_vssrani_du_q(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrarni_b_h(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vssrarni_b_h(transmute(a), transmute(b), IMM4)) } @@ -3530,7 +3530,7 @@ pub fn lsx_vssrarni_b_h(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrarni_h_w(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vssrarni_h_w(transmute(a), transmute(b), IMM5)) } @@ -3538,7 +3538,7 @@ pub fn lsx_vssrarni_h_w(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrarni_w_d(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lsx_vssrarni_w_d(transmute(a), transmute(b), IMM6)) } @@ -3546,7 +3546,7 @@ pub fn lsx_vssrarni_w_d(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrarni_d_q(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lsx_vssrarni_d_q(transmute(a), transmute(b), IMM7)) } @@ -3554,7 +3554,7 @@ pub fn lsx_vssrarni_d_q(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrarni_bu_h(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM4, 4); unsafe { transmute(__lsx_vssrarni_bu_h(transmute(a), transmute(b), IMM4)) } @@ -3562,7 +3562,7 @@ pub fn lsx_vssrarni_bu_h(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrarni_hu_w(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM5, 5); unsafe { transmute(__lsx_vssrarni_hu_w(transmute(a), transmute(b), IMM5)) } @@ -3570,7 +3570,7 @@ pub fn lsx_vssrarni_hu_w(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrarni_wu_d(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM6, 6); unsafe { transmute(__lsx_vssrarni_wu_d(transmute(a), transmute(b), IMM6)) } @@ -3578,7 +3578,7 @@ pub fn lsx_vssrarni_wu_d(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrarni_du_q(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM7, 7); unsafe { transmute(__lsx_vssrarni_du_q(transmute(a), transmute(b), IMM7)) } @@ -3586,7 +3586,7 @@ pub fn lsx_vssrarni_du_q(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vpermi_w(a: m128i, b: m128i) -> m128i { static_assert_uimm_bits!(IMM8, 8); unsafe { transmute(__lsx_vpermi_w(transmute(a), transmute(b), IMM8)) } @@ -3594,434 +3594,434 @@ pub fn lsx_vpermi_w(a: m128i, b: m128i) -> m128i { #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlrn_b_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssrlrn_b_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlrn_h_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssrlrn_h_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrlrn_w_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssrlrn_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrln_b_h(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssrln_b_h(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrln_h_w(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssrln_h_w(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vssrln_w_d(a: m128i, b: m128i) -> m128i { unsafe { transmute(__lsx_vssrln_w_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vshuf_b(a: m128i, b: m128i, c: m128i) -> m128i { unsafe { transmute(__lsx_vshuf_b(transmute(a), transmute(b), transmute(c))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vextl_qu_du(a: m128i) -> m128i { unsafe { transmute(__lsx_vextl_qu_du(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_bnz_b(a: m128i) -> i32 { unsafe { transmute(__lsx_bnz_b(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_bnz_d(a: m128i) -> i32 { unsafe { transmute(__lsx_bnz_d(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_bnz_h(a: m128i) -> i32 { unsafe { transmute(__lsx_bnz_h(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_bnz_v(a: m128i) -> i32 { unsafe { transmute(__lsx_bnz_v(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_bnz_w(a: m128i) -> i32 { unsafe { transmute(__lsx_bnz_w(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_bz_b(a: m128i) -> i32 { unsafe { transmute(__lsx_bz_b(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_bz_d(a: m128i) -> i32 { unsafe { transmute(__lsx_bz_d(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_bz_h(a: m128i) -> i32 { unsafe { transmute(__lsx_bz_h(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_bz_v(a: m128i) -> i32 { unsafe { transmute(__lsx_bz_v(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_bz_w(a: m128i) -> i32 { unsafe { transmute(__lsx_bz_w(transmute(a))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_caf_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_caf_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_caf_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_caf_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_ceq_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_ceq_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_ceq_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_ceq_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_cle_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_cle_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_cle_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_cle_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_clt_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_clt_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_clt_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_clt_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_cne_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_cne_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_cne_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_cne_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_cor_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_cor_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_cor_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_cor_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_cueq_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_cueq_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_cueq_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_cueq_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_cule_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_cule_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_cule_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_cule_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_cult_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_cult_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_cult_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_cult_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_cun_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_cun_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_cune_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_cune_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_cune_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_cune_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_cun_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_cun_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_saf_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_saf_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_saf_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_saf_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_seq_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_seq_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_seq_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_seq_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_sle_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_sle_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_sle_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_sle_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_slt_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_slt_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_slt_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_slt_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_sne_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_sne_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_sne_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_sne_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_sor_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_sor_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_sor_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_sor_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_sueq_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_sueq_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_sueq_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_sueq_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_sule_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_sule_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_sule_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_sule_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_sult_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_sult_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_sult_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_sult_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_sun_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_sun_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_sune_d(a: m128d, b: m128d) -> m128i { unsafe { transmute(__lsx_vfcmp_sune_d(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_sune_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_sune_s(transmute(a), transmute(b))) } } #[inline] #[target_feature(enable = "lsx")] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn lsx_vfcmp_sun_s(a: m128, b: m128) -> m128i { unsafe { transmute(__lsx_vfcmp_sun_s(transmute(a), transmute(b))) } } diff --git a/library/stdarch/crates/core_arch/src/loongarch64/lsx/mod.rs b/library/stdarch/crates/core_arch/src/loongarch64/lsx/mod.rs index 7ad1009f0245a..77099bb2fd541 100644 --- a/library/stdarch/crates/core_arch/src/loongarch64/lsx/mod.rs +++ b/library/stdarch/crates/core_arch/src/loongarch64/lsx/mod.rs @@ -6,21 +6,21 @@ mod types; #[rustfmt::skip] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub use self::types::*; #[rustfmt::skip] mod generated; #[rustfmt::skip] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub use self::generated::*; #[rustfmt::skip] mod portable; #[rustfmt::skip] -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub use self::portable::*; #[rustfmt::skip] diff --git a/library/stdarch/crates/core_arch/src/loongarch64/lsx/types.rs b/library/stdarch/crates/core_arch/src/loongarch64/lsx/types.rs index 2d331498f19b9..38a502377feeb 100644 --- a/library/stdarch/crates/core_arch/src/loongarch64/lsx/types.rs +++ b/library/stdarch/crates/core_arch/src/loongarch64/lsx/types.rs @@ -1,5 +1,5 @@ types! { - #![stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #![stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] /// 128-bit wide integer vector type, LoongArch-specific /// diff --git a/library/stdarch/crates/core_arch/src/loongarch64/mod.rs b/library/stdarch/crates/core_arch/src/loongarch64/mod.rs index 77c6033a71cc1..467a7c717f3c5 100644 --- a/library/stdarch/crates/core_arch/src/loongarch64/mod.rs +++ b/library/stdarch/crates/core_arch/src/loongarch64/mod.rs @@ -4,9 +4,9 @@ mod lasx; mod lsx; mod simd; -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub use self::lasx::*; -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub use self::lsx::*; use crate::arch::asm; diff --git a/library/stdarch/crates/core_arch/src/loongarch64/simd.rs b/library/stdarch/crates/core_arch/src/loongarch64/simd.rs index 3152864ab864e..e7c7bad410cf9 100644 --- a/library/stdarch/crates/core_arch/src/loongarch64/simd.rs +++ b/library/stdarch/crates/core_arch/src/loongarch64/simd.rs @@ -308,7 +308,7 @@ macro_rules! impl_vavg { ($ft:literal, $name:ident, $oty:ty, $ity:ty, $wty:ty) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn $name(a: $oty, b: $oty) -> $oty { unsafe { let a: $wty = simd_cast(transmute::<_, $ity>(a)); @@ -324,7 +324,7 @@ macro_rules! impl_vavgr { ($ft:literal, $name:ident, $oty:ty, $ity:ty, $wty:ty) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn $name(a: $oty, b: $oty) -> $oty { unsafe { let a: $wty = simd_cast(transmute::<_, $ity>(a)); @@ -346,7 +346,7 @@ macro_rules! impl_vv { ($ft:literal, $name:ident, $op:ident, $oty:ty, $ity:ty) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn $name(a: $oty) -> $oty { unsafe { let a: $ity = transmute(a); @@ -363,7 +363,7 @@ macro_rules! impl_gv { ($ft:literal, $name:ident, $op:ident, $oty:ty, $ity:ident, $gty:ty) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn $name(a: $gty) -> $oty { unsafe { let r: $ity = $op(a.into()); @@ -379,7 +379,7 @@ macro_rules! impl_ggv { ($ft:literal, $name:ident, $op:ident, $oty:ty, $ity:ident, $gty:ty, $xty:ty, unsafe) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn $name(a: $gty, b: $xty) -> $oty { let r: $ity = $op(a, b); transmute(r) @@ -393,7 +393,7 @@ macro_rules! impl_gsv { ($ft:literal, $name:ident, $op:ident, $oty:ty, $ity:ident, $gty:ty, $ibs:expr, const, unsafe) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn $name(a: $gty) -> $oty { static_assert_simm_bits!(IMM, $ibs); let r: $ity = $op::(a); @@ -408,7 +408,7 @@ macro_rules! impl_sv { ($ft:literal, $name:ident, $op:ident, $oty:ty, $ity:ident, $ibs:expr) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn $name() -> $oty { static_assert_simm_bits!(IMM, $ibs); unsafe { @@ -420,7 +420,7 @@ macro_rules! impl_sv { ($ft:literal, $name:ident, $op:ident, $oty:ty, $ity:ident, $ibs:expr, const) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn $name() -> $oty { static_assert_simm_bits!(IMM, $ibs); unsafe { @@ -437,7 +437,7 @@ macro_rules! impl_vvv { ($ft:literal, $name:ident, $op:ident, $oty:ty, $ity:ty) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn $name(a: $oty, b: $oty) -> $oty { unsafe { let a: $ity = transmute(a); @@ -450,7 +450,7 @@ macro_rules! impl_vvv { ($ft:literal, $name:ident, $op:ident, $oty:ty, $ity:ty, $wty:ty) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn $name(a: $oty, b: $oty) -> $oty { unsafe { let a: $ity = transmute(a); @@ -468,7 +468,7 @@ macro_rules! impl_vgg { ($ft:literal, $name:ident, $op:ident, $oty:ty, $ity:ident, $gty:ty, $xty:ty, unsafe) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn $name(a: $oty, b: $gty, c: $xty) { $op(a, b, c); } @@ -481,7 +481,7 @@ macro_rules! impl_vgs { ($ft:literal, $name:ident, $op:ident, $oty:ty, $ity:ident, $gty:ty, $ibs:expr, const, unsafe) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub unsafe fn $name(a: $oty, b: $gty) { static_assert_simm_bits!(IMM, $ibs); $op::(a, b); @@ -495,7 +495,7 @@ macro_rules! impl_vuv { ($ft:literal, $name:ident, $op:ident, $oty:ty, $ity:ident) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn $name(a: $oty) -> $oty { static_assert_uimm_bits!(IMM, (size_of::<<$ity as SimdExt>::Elem>() * 8).ilog2()); unsafe { @@ -509,7 +509,7 @@ macro_rules! impl_vuv { ($ft:literal, $name:ident, $op:ident, $oty:ty, $ity:ident, $ibs:expr) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn $name(a: $oty) -> $oty { static_assert_uimm_bits!(IMM, $ibs); unsafe { @@ -523,7 +523,7 @@ macro_rules! impl_vuv { ($ft:literal, $name:ident, $op:ident, $oty:ty, $ity:ident, $ibs:expr, const) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn $name(a: $oty) -> $oty { static_assert_uimm_bits!(IMM, $ibs); unsafe { @@ -541,7 +541,7 @@ macro_rules! impl_vug { ($ft:literal, $name:ident, $op:ident, $oty:ty, $ity:ident, $gty:ty, $ibs:expr) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn $name(a: $oty) -> $gty { static_assert_uimm_bits!(IMM, $ibs); unsafe { @@ -559,7 +559,7 @@ macro_rules! impl_vsv { ($ft:literal, $name:ident, $op:ident, $oty:ty, $ity:ident, $ibs:expr) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn $name(a: $oty) -> $oty { static_assert_simm_bits!(IMM, $ibs); unsafe { @@ -578,7 +578,7 @@ macro_rules! impl_vvvv { ($ft:literal, $name:ident, $op:ident, $oty:ty, $ity:ty) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn $name(a: $oty, b: $oty, c: $oty) -> $oty { unsafe { let a: $ity = transmute(a); @@ -597,7 +597,7 @@ macro_rules! impl_vvuv { ($ft:literal, $name:ident, $op:ident, $oty:ty, $ity:ident, $ibs:expr, const) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn $name(a: $oty, b: $oty) -> $oty { static_assert_uimm_bits!(IMM, $ibs); unsafe { @@ -616,7 +616,7 @@ macro_rules! impl_vugv { ($ft:literal, $name:ident, $op:ident, $oty:ty, $ity:ident, $gty:ty, $ibs:expr) => { #[inline] #[target_feature(enable = $ft)] - #[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] pub fn $name(a: $oty, b: $gty) -> $oty { static_assert_uimm_bits!(IMM, $ibs); unsafe { diff --git a/library/stdarch/crates/core_arch/src/mod.rs b/library/stdarch/crates/core_arch/src/mod.rs index 4583142cd59cd..d19ed25a5b140 100644 --- a/library/stdarch/crates/core_arch/src/mod.rs +++ b/library/stdarch/crates/core_arch/src/mod.rs @@ -308,11 +308,11 @@ pub mod arch { /// See the [module documentation](../index.html) for more details. #[cfg(any(target_arch = "loongarch64", doc))] #[doc(cfg(target_arch = "loongarch64"))] - #[stable(feature = "stdarch_loongarch64", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch64", since = "1.101.0")] pub mod loongarch64 { - #[stable(feature = "stdarch_loongarch64", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch64", since = "1.101.0")] pub use crate::core_arch::loongarch_shared::*; - #[stable(feature = "stdarch_loongarch64", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "stdarch_loongarch64", since = "1.101.0")] pub use crate::core_arch::loongarch64::*; } diff --git a/library/stdarch/crates/stdarch-gen-loongarch/src/main.rs b/library/stdarch/crates/stdarch-gen-loongarch/src/main.rs index 02ebf6ffe10a5..97b7d94e6a625 100644 --- a/library/stdarch/crates/stdarch-gen-loongarch/src/main.rs +++ b/library/stdarch/crates/stdarch-gen-loongarch/src/main.rs @@ -607,7 +607,7 @@ fn gen_bind_body( let function = format!( r#" #[inline]{target_feature} -#[stable(feature = "stdarch_loongarch_simd", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "stdarch_loongarch_simd", since = "1.101.0")] {fn_decl}{{ {call_params} }} diff --git a/library/unwind/src/types.rs b/library/unwind/src/types.rs index d299d8e7e2252..d745b836e822b 100644 --- a/library/unwind/src/types.rs +++ b/library/unwind/src/types.rs @@ -19,28 +19,27 @@ pub use _Unwind_Reason_Code::*; pub type _Unwind_Exception_Class = u64; pub type _Unwind_Word = *const u8; -pub const unwinder_private_data_size: usize = - cfg_select! { - target_arch = "x86" => 5, - all(target_arch = "x86_64", not(any(target_os = "windows", target_os = "cygwin"))) => 2, - all(target_arch = "x86_64", any(target_os = "windows", target_os = "cygwin")) => 6, - all(target_arch = "arm", not(target_vendor = "apple")) => 20, - all(target_arch = "arm", target_vendor = "apple") => 5, - all(target_arch = "aarch64", target_pointer_width = "64", not(target_os = "windows")) => 2, - all(target_arch = "aarch64", target_pointer_width = "64", target_os = "windows") => 6, - all(target_arch = "aarch64", target_pointer_width = "32") => 5, - target_arch = "m68k" => 2, - any(target_arch = "mips", target_arch = "mips32r6") => 2, - target_arch = "csky" => 2, - any(target_arch = "mips64", target_arch = "mips64r6") => 2, - any(target_arch = "powerpc", target_arch = "powerpc64") => 2, - target_arch = "s390x" => 2, - any(target_arch = "sparc", target_arch = "sparc64") => 2, - any(target_arch = "riscv64", target_arch = "riscv32") => 2, - target_family = "wasm" => 2, - target_arch = "hexagon" => 5, - any(target_arch = "loongarch32", target_arch = "loongarch64") => 2, - }; +pub const unwinder_private_data_size: usize = cfg_select! { + target_arch = "x86" => 5, + all(target_arch = "x86_64", not(any(target_os = "windows", target_os = "cygwin"))) => 2, + all(target_arch = "x86_64", any(target_os = "windows", target_os = "cygwin")) => 6, + all(target_arch = "arm", not(target_vendor = "apple")) => 20, + all(target_arch = "arm", target_vendor = "apple") => 5, + all(target_arch = "aarch64", target_pointer_width = "64", not(target_os = "windows")) => 2, + all(target_arch = "aarch64", target_pointer_width = "64", target_os = "windows") => 6, + all(target_arch = "aarch64", target_pointer_width = "32") => 5, + target_arch = "m68k" => 2, + any(target_arch = "mips", target_arch = "mips32r6") => 2, + target_arch = "csky" => 2, + any(target_arch = "mips64", target_arch = "mips64r6") => 2, + any(target_arch = "powerpc", target_arch = "powerpc64") => 2, + target_arch = "s390x" => 2, + any(target_arch = "sparc", target_arch = "sparc64") => 2, + any(target_arch = "riscv64", target_arch = "riscv32") => 2, + target_family = "wasm" => 2, + target_arch = "hexagon" => 5, + any(target_arch = "loongarch32", target_arch = "loongarch64") => 2, +}; #[repr(C)] // The Itanium C++ ABI requires this type to have "double-word" alignment, diff --git a/src/bootstrap/src/core/sanity.rs b/src/bootstrap/src/core/sanity.rs index ac44a4dfca9b1..6983030fedd0a 100644 --- a/src/bootstrap/src/core/sanity.rs +++ b/src/bootstrap/src/core/sanity.rs @@ -36,7 +36,6 @@ pub struct Finder { /// when the newly-bumped stage 0 compiler now knows about the formerly-missing targets. const STAGE0_MISSING_TARGETS: &[&str] = &[ // just a dummy comment so the list doesn't get onelined - "aarch64-unknown-qtee", ]; /// Minimum version threshold for libstdc++ required when using prebuilt LLVM diff --git a/src/stage0 b/src/stage0 index 65357a133fe09..341d8499f8ce8 100644 --- a/src/stage0 +++ b/src/stage0 @@ -13,588 +13,588 @@ nightly_branch=main # All changes below this comment will be overridden the next time the # tool is executed. -compiler_channel_manifest_hash=748739f565e7977153cc87b1bf606072e31088a751ed351c1a076cfc4ebd04ed -compiler_git_commit_hash=e3feeb59cd1bdd011a2bfcc0747b55125d9b8527 -compiler_date=2026-09-29 +compiler_channel_manifest_hash=bc1c6b4a0a9f8b7004b236851654f3e42855b301e500632792a5dcbaad99bd87 +compiler_git_commit_hash=bbcdfd90a3f81ca2a5f6d69b943a6ff0d8582102 +compiler_date=2026-11-10 compiler_version=beta -rustfmt_channel_manifest_hash=4ac7009a2d787fa804178e5a7a067b1f828f85623a160ef7cc417d378814ef3e -rustfmt_git_commit_hash=c1070d69382b8d2f2eb65119c738a77d9e324c9e -rustfmt_date=2026-09-29 +rustfmt_channel_manifest_hash=c2986ce080bf1c0e2b96a20d8e704ab33fdd95f1e347f75e0e6ace780909620c +rustfmt_git_commit_hash=ac8310ba643a3796cbe77d2e06944d7c8513999f +rustfmt_date=2026-11-10 rustfmt_version=nightly -dist/2026-09-29/rustc-beta-aarch64-apple-darwin.tar.gz=08cb5170859d6ebf335c279df46cd8421e6478a0199d0cd2709c0afbe8a92dc2 -dist/2026-09-29/rustc-beta-aarch64-apple-darwin.tar.xz=5ec30352066404071c4c9a077e19b211e1e2865babec422c1b5305882fccb2f8 -dist/2026-09-29/rustc-beta-aarch64-pc-windows-gnullvm.tar.gz=24630c62a81890608c84b0c5d1ccba809c7414c9cfa6737b092bdcb3defb6797 -dist/2026-09-29/rustc-beta-aarch64-pc-windows-gnullvm.tar.xz=b9db7c497276274a7e5af4ae6666d4d77bb9ebe8a389513c1628488f4f86b950 -dist/2026-09-29/rustc-beta-aarch64-pc-windows-msvc.tar.gz=75b429e1d1f34317877ce3838e4e5c79ea579a051314fce9755ecd92782031e4 -dist/2026-09-29/rustc-beta-aarch64-pc-windows-msvc.tar.xz=04fb7d879ff7b00ed5cc3a054bfd8f4dfcbcc039c1000334db34284b6b7d0d27 -dist/2026-09-29/rustc-beta-aarch64-unknown-freebsd.tar.gz=4a4ece6cb6b686d844d3d93c6b5cc50dcc6fd1a2aac17d7ff7606cc3fe103980 -dist/2026-09-29/rustc-beta-aarch64-unknown-freebsd.tar.xz=2bfd413768c42feade1655007488e4cb913fc5b295763dd7835224e5a57ab198 -dist/2026-09-29/rustc-beta-aarch64-unknown-linux-gnu.tar.gz=c60b31aec10e123a0c461b6f86b0f7d18dd22e706abe76ed4d9ea010c76e1fc1 -dist/2026-09-29/rustc-beta-aarch64-unknown-linux-gnu.tar.xz=ecc23a873a11fcbe2b81e47763204f93a1f91e551c0fa8766262ffa2cc3d0538 -dist/2026-09-29/rustc-beta-aarch64-unknown-linux-musl.tar.gz=1634c9acebc04a266987633062e0db4d4b5a92a568ae55cb146cffba8108038d -dist/2026-09-29/rustc-beta-aarch64-unknown-linux-musl.tar.xz=4361c19fcc2cf8e26bb52489e7dd3e96500c6e6d54bbeaa1493d0b8c8d6a066e -dist/2026-09-29/rustc-beta-aarch64-unknown-linux-ohos.tar.gz=318e6fae90b8da5cad5eea22d358b848746a8f4fcf60d164a2d630f03d12facf -dist/2026-09-29/rustc-beta-aarch64-unknown-linux-ohos.tar.xz=7d80d8a51de0f9a8f0af2ac170e5156a14dba2f3952946a845917f772e9c7dbb -dist/2026-09-29/rustc-beta-arm-unknown-linux-gnueabi.tar.gz=7dc6dcfa998512791269d52f9ee0097bfea867c3a02a54c676c88a69a40f8a23 -dist/2026-09-29/rustc-beta-arm-unknown-linux-gnueabi.tar.xz=b791b3ed832746088ed4ec8378f9b226a7900c4fd4cbe6436f7425191ef1013f -dist/2026-09-29/rustc-beta-arm-unknown-linux-gnueabihf.tar.gz=0a1bab07aafcc98cbb130b81b3ad9eceff1194037110fc8ed7fa6650a572ab07 -dist/2026-09-29/rustc-beta-arm-unknown-linux-gnueabihf.tar.xz=677ee4e95a57d1e498ac4bd9ac05084675c03c58de6e85320d7d6d0c725e6ebc -dist/2026-09-29/rustc-beta-armv7-unknown-linux-gnueabihf.tar.gz=e7de0b8ec0715ee54866b533f22ffe23b560e58884228f145e0458a3dfb0450b -dist/2026-09-29/rustc-beta-armv7-unknown-linux-gnueabihf.tar.xz=6316b4bc4931c2811c90d7dff9df5bf7875531c6cf985c065f78b8a0577e370f -dist/2026-09-29/rustc-beta-i686-unknown-linux-gnu.tar.gz=8229d9b5bb6497abdedf15731c15c2ae85c8050bf0995a576685716e9d929ac8 -dist/2026-09-29/rustc-beta-i686-unknown-linux-gnu.tar.xz=428ba34f2281ddbb794a2062e446ca6e5b0cd90a84829186f769bb8d2190a28c -dist/2026-09-29/rustc-beta-loongarch64-unknown-linux-gnu.tar.gz=04ab37c4e7e9dde5a2332975b6f7cfe6c02319e89f9bab2128945656ec81110a -dist/2026-09-29/rustc-beta-loongarch64-unknown-linux-gnu.tar.xz=50d6c00c82dfb7f10bd2c49057822e082c3bc1f6cb7a08e06ac2a5a350e1d1eb -dist/2026-09-29/rustc-beta-loongarch64-unknown-linux-musl.tar.gz=9fc8d551462b4a845c18f163c2787e256d00d4edcaca0721da63ab57002f418c -dist/2026-09-29/rustc-beta-loongarch64-unknown-linux-musl.tar.xz=ce74c12908e44b8b87fdb371533b6a81b5cbc8967e04209b833c87940f4a1420 -dist/2026-09-29/rustc-beta-powerpc-unknown-linux-gnu.tar.gz=e7417324e10e59b5768daa4b5cd01fe92a624739a9b450693fbd5902227a3561 -dist/2026-09-29/rustc-beta-powerpc-unknown-linux-gnu.tar.xz=68dbbc9c7f6c1f2725140c0edd58e3607cd31d4406e7514cb32b9a894f3af39e -dist/2026-09-29/rustc-beta-powerpc64-unknown-linux-gnu.tar.gz=93b02c260b6ace5ea43fd716a100abfb2ed3de24a53e3032794c35858fb0f618 -dist/2026-09-29/rustc-beta-powerpc64-unknown-linux-gnu.tar.xz=e78037526d62c567cb2aa1336c0ed2bfde01e2948833c10a3585040dcf26f343 -dist/2026-09-29/rustc-beta-powerpc64-unknown-linux-musl.tar.gz=3ee5c15579228dc36bef6b254fc235ff57426be8dba7bb358beaed0f1791afc0 -dist/2026-09-29/rustc-beta-powerpc64-unknown-linux-musl.tar.xz=053fbdbfdce20029dedadf7218daabee5b181a69c20b46c2849970f9fa91a7a2 -dist/2026-09-29/rustc-beta-powerpc64le-unknown-linux-gnu.tar.gz=a0d9ad02f3f031d54080f3a64f97d099f38de9b324e3906ecd9f873f8353167f -dist/2026-09-29/rustc-beta-powerpc64le-unknown-linux-gnu.tar.xz=8a81d01e78892fbfadfb22b59c6264bcaf4343e36afa806d94b2c6f51eedde43 -dist/2026-09-29/rustc-beta-powerpc64le-unknown-linux-musl.tar.gz=5780592d8b617c2a2b3c1a0c142e71ba589ce5a6ca8d05840668ed9b0217e807 -dist/2026-09-29/rustc-beta-powerpc64le-unknown-linux-musl.tar.xz=e71f58d7383c5ce823ede7d7d032349a3616ec3c3fcae212786b24ec4e427fcd -dist/2026-09-29/rustc-beta-riscv64gc-unknown-linux-gnu.tar.gz=3f113901c2996c2bc39891cc6146fa4c2d8800029258186805b20a34dac0ab13 -dist/2026-09-29/rustc-beta-riscv64gc-unknown-linux-gnu.tar.xz=2b7bfe0f71378a76c4b5bc04224f728c02b0cf21d66999d86a33b754ff80b52a -dist/2026-09-29/rustc-beta-riscv64gc-unknown-linux-musl.tar.gz=b4e6d98741d7293f16ab9218e5492664765f43cbc7f8537b45ef6815ca83b0bb -dist/2026-09-29/rustc-beta-riscv64gc-unknown-linux-musl.tar.xz=98141ecd5a1426d8b168e5f181bacf083150895e446840d2243747159bdc3773 -dist/2026-09-29/rustc-beta-s390x-unknown-linux-gnu.tar.gz=5b821594334d8f9b1d07264df899f22fe7a041d7417618b8e7809973fd45ae22 -dist/2026-09-29/rustc-beta-s390x-unknown-linux-gnu.tar.xz=5c52006d530dbd13711e01402dc533c1d664f77e4f1c997179b900ce29ccc617 -dist/2026-09-29/rustc-beta-sparcv9-sun-solaris.tar.gz=7db0a06f0450e2f47ebae3912fff144d416cfe58877ff8996d1335af634bc7db -dist/2026-09-29/rustc-beta-sparcv9-sun-solaris.tar.xz=3d8c85b04fa3d1947840867c5ffb750ae341ad17982aca302abc754e43e1ff42 -dist/2026-09-29/rustc-beta-x86_64-apple-darwin.tar.gz=2bf2b522df594f578642b9c1670b265a02b937b48b5b47ace32a53ad7b569200 -dist/2026-09-29/rustc-beta-x86_64-apple-darwin.tar.xz=ed18e8348eba7bbc6adfd6b95292d802834022a243bd9739cfdbc5d69d8e7e2f -dist/2026-09-29/rustc-beta-x86_64-pc-solaris.tar.gz=cce6ce17920028ed75d83134bae4e02704bf497002b654ff629dedd8294a8335 -dist/2026-09-29/rustc-beta-x86_64-pc-solaris.tar.xz=6d5cb6a91f23044f79c73954bf392989d031412e4d6b43e18d4256d7a3c1fb0c -dist/2026-09-29/rustc-beta-x86_64-pc-windows-gnu.tar.gz=efea45514b6313626db60fa3e922fbd812454004c34c79e3770050826da93022 -dist/2026-09-29/rustc-beta-x86_64-pc-windows-gnu.tar.xz=5a32405ad9ffe040516efd73d961ca53f89c1cd8b4bd8eadb900caef8303e0c3 -dist/2026-09-29/rustc-beta-x86_64-pc-windows-gnullvm.tar.gz=6e911af2547846c6baa414b7d85288d954293df34b5cc87805aa6bb06570dc48 -dist/2026-09-29/rustc-beta-x86_64-pc-windows-gnullvm.tar.xz=e1ad982eccf000e89da01d6910cf918d2231e3cdcc3738f6696d3d57dfa5f353 -dist/2026-09-29/rustc-beta-x86_64-pc-windows-msvc.tar.gz=fd2d7a0809aa431f3f2365f6a98901f359514d47967067c936ba68bc47437d5c -dist/2026-09-29/rustc-beta-x86_64-pc-windows-msvc.tar.xz=ea968def39864e80a462e6be752a7fab2a8c9da7f14799b138ddf0e9bc1f534d -dist/2026-09-29/rustc-beta-x86_64-unknown-freebsd.tar.gz=87deb753d7a5af1afc02cc988d23ea0d42a9573b5e9abbed23ff8f345a91056e -dist/2026-09-29/rustc-beta-x86_64-unknown-freebsd.tar.xz=2dbaa50d6542748cd31dc9f13d4fb82874825634f027317b830121937b583d76 -dist/2026-09-29/rustc-beta-x86_64-unknown-illumos.tar.gz=f682c3ad10ae60d43e2a54a3f624782c9ef0ae61fb0e9ed95a867794e0bff256 -dist/2026-09-29/rustc-beta-x86_64-unknown-illumos.tar.xz=0ad43335ebc8b0d1dbdaa34aa53fbc0cba9a8186b5edac080f5a7bf7ed7cde7d -dist/2026-09-29/rustc-beta-x86_64-unknown-linux-gnu.tar.gz=c567617a07be89de49b009162604ef9bfe4bc542419d405c444e39714591f4de -dist/2026-09-29/rustc-beta-x86_64-unknown-linux-gnu.tar.xz=e562beb9a7ccda3e99c79b2f37149fe5dacdb1f3bb7bdb77ec94b1a947daf009 -dist/2026-09-29/rustc-beta-x86_64-unknown-linux-musl.tar.gz=cea2a33fbacd6b80a7e19592a2ca8f58eb1613589dbd8c906ae78b5723cebe6e -dist/2026-09-29/rustc-beta-x86_64-unknown-linux-musl.tar.xz=e0a1889de08bc4c91006e1d335ed7215257de80bbf6bae375906021ada6dd95b -dist/2026-09-29/rustc-beta-x86_64-unknown-netbsd.tar.gz=262db7c3e54259876fa7f03775b73a5f190cd4812060feac04c13a03db1c5343 -dist/2026-09-29/rustc-beta-x86_64-unknown-netbsd.tar.xz=547adcdda9c63d0f63f8351dee197ca843628bfb1f965e8305f947ca128a2f69 -dist/2026-09-29/rust-std-beta-aarch64-apple-darwin.tar.gz=12a712c301ab944900438c0da63b45ec133efea74b398e708faed172e2960042 -dist/2026-09-29/rust-std-beta-aarch64-apple-darwin.tar.xz=d9705141deb514ad2d721ae34174c33ab5b64ab7181294886cbbfdc3f9b999ae -dist/2026-09-29/rust-std-beta-aarch64-apple-ios.tar.gz=3a65781d05da1559788ea8bc2df4d84f12fdc4194cfcece0863ce786ead5ec13 -dist/2026-09-29/rust-std-beta-aarch64-apple-ios.tar.xz=728a2be2bbbacf3866e007d92b9f0857a9b7da0d0c47c16e296fba25839afbf4 -dist/2026-09-29/rust-std-beta-aarch64-apple-ios-macabi.tar.gz=b445edeeddab84fac96c089d73f3a87e485415583ddbff217092058c14c79c9b -dist/2026-09-29/rust-std-beta-aarch64-apple-ios-macabi.tar.xz=db73dd68d6a0458b7ab9e49f2e331a460f14eb4598af19f2a6f642b85db3c947 -dist/2026-09-29/rust-std-beta-aarch64-apple-ios-sim.tar.gz=09d2bbd7f44f6245ff9e7ffdccec0a491e9195075232cfca2f247329b0371aa8 -dist/2026-09-29/rust-std-beta-aarch64-apple-ios-sim.tar.xz=1faee83ec196e8a2876c06dd5377a542aac1aa32c7d3b00ecf31a3713b50555c -dist/2026-09-29/rust-std-beta-aarch64-apple-tvos.tar.gz=e8d1cd23d78eacb8a4be5cb465b94902b5351573b4c0a47073205ec4c8028397 -dist/2026-09-29/rust-std-beta-aarch64-apple-tvos.tar.xz=42f013a0c3ad79263d651b194dab7b08734f6a96dd5943535706f4a8990ca819 -dist/2026-09-29/rust-std-beta-aarch64-apple-tvos-sim.tar.gz=a5381d8ed927c6e1c720833462898ca6c4bdae6702e308352f0dc5698e3fb93f -dist/2026-09-29/rust-std-beta-aarch64-apple-tvos-sim.tar.xz=6ffd6d6d7bc230e28a78f7230b0b91fc71dda6af018feae186b0eb48910234c6 -dist/2026-09-29/rust-std-beta-aarch64-apple-visionos.tar.gz=90a82a478d671ed7269f7cfb5eeaa70cb914d9424dd741c7a2ad2b4a26840b6b -dist/2026-09-29/rust-std-beta-aarch64-apple-visionos.tar.xz=1c700b45a80f7304fe00977cb2fe46975ce16ac31494f2e5afc825465b475d02 -dist/2026-09-29/rust-std-beta-aarch64-apple-visionos-sim.tar.gz=50113f0e4b4cbd8c528978a6ead8fc3fcf15dc6b1c4bf97488a61da8d9245dfe -dist/2026-09-29/rust-std-beta-aarch64-apple-visionos-sim.tar.xz=fbd9564bbdd9d0d43fb00fe67a83fad16a58d4545982344bdbacad93dd53b110 -dist/2026-09-29/rust-std-beta-aarch64-apple-watchos.tar.gz=6ba080aa355f112b74c180ee6ef1ed182bad260f35e4816bf22f758af1782286 -dist/2026-09-29/rust-std-beta-aarch64-apple-watchos.tar.xz=979686c0acca1dfe4bbc1906bbb7dd268b90b9aac3dd97a06f105fbc3260f78d -dist/2026-09-29/rust-std-beta-aarch64-apple-watchos-sim.tar.gz=4d3459fa110abab0d95e1748f5426f162d746635529839d88360dd7c186a9a0b -dist/2026-09-29/rust-std-beta-aarch64-apple-watchos-sim.tar.xz=303623e7c027952c164dae9e8662c1141914a35c7af148de8e7b0cd813594384 -dist/2026-09-29/rust-std-beta-aarch64-linux-android.tar.gz=cf7c1de2dbdfd3ac05131e63cc6285c5d76e8ae85c186350a164ce1017a6a1c9 -dist/2026-09-29/rust-std-beta-aarch64-linux-android.tar.xz=790d34c2a756240cad1da2662132eb11ffa2b3e844ba639c3561aa5ba0d3ae97 -dist/2026-09-29/rust-std-beta-aarch64-pc-windows-gnullvm.tar.gz=dde06b88182f2f6bad4d7b2cfd40a99ecccac1fdc2dee3ef5e65f425e706484f -dist/2026-09-29/rust-std-beta-aarch64-pc-windows-gnullvm.tar.xz=f901b2689461d3b38b5f2eec0a6f5c6795ee3638da97a433c1fa84ecff11a082 -dist/2026-09-29/rust-std-beta-aarch64-pc-windows-msvc.tar.gz=943394d1133a8c82da94d97ae738472666a9ae4f2d04c504171d8bae34a13f21 -dist/2026-09-29/rust-std-beta-aarch64-pc-windows-msvc.tar.xz=6777866c103e45b453d7ad36d3addc3bfa09684b6e6e4abe18ea5ef782ade595 -dist/2026-09-29/rust-std-beta-aarch64-unknown-freebsd.tar.gz=5b2e8bf0dfa7a5be26a3d969c708e5181149982877a3d571d75ad2c118b56ef8 -dist/2026-09-29/rust-std-beta-aarch64-unknown-freebsd.tar.xz=b5146618aee2bdeea3f3da4c6afe4b07d6b8af0440f6d954985973d12dc7ec9e -dist/2026-09-29/rust-std-beta-aarch64-unknown-fuchsia.tar.gz=e92c49005a09ba23a21cc74364f30769997f7b6b81c2205ee7e9d9413fb38fb7 -dist/2026-09-29/rust-std-beta-aarch64-unknown-fuchsia.tar.xz=fca1e29e1856abe923cccef58d560074d2d5adac5211007c00e0657677ea7f57 -dist/2026-09-29/rust-std-beta-aarch64-unknown-linux-gnu.tar.gz=9d02af2c761d752a1371e301753a432031984cfaf53d9812c8ce540bfbf6d716 -dist/2026-09-29/rust-std-beta-aarch64-unknown-linux-gnu.tar.xz=e991bfc2818af00b53cfac0535d094135712339b8f1289186a6d0f8d209ff351 -dist/2026-09-29/rust-std-beta-aarch64-unknown-linux-musl.tar.gz=405f757b12a00629b2f2dfd0ebf3c372d257047fd8ddf348088ed78235fc0e7b -dist/2026-09-29/rust-std-beta-aarch64-unknown-linux-musl.tar.xz=c8dd6d868b2f6b316433bb1849a809450bae0fab9305c60b2123816066e69d71 -dist/2026-09-29/rust-std-beta-aarch64-unknown-linux-ohos.tar.gz=4fb73dd34675a6f27b6426f58ad7be879ff49ab8e98c3ce003e49651bbacee4a -dist/2026-09-29/rust-std-beta-aarch64-unknown-linux-ohos.tar.xz=a89e58073a28be60905bb7647f0e60b4520639f5460cfc3c6f1e25c581939864 -dist/2026-09-29/rust-std-beta-aarch64-unknown-none.tar.gz=b7bb5e2d07dfb49786bc1f9de858c3a41a6c4723df4e48152905616867389617 -dist/2026-09-29/rust-std-beta-aarch64-unknown-none.tar.xz=0c0fc594ad1d67be737ec709d3e10ed319d3e5a4263d1951a9bfe664bd2504b3 -dist/2026-09-29/rust-std-beta-aarch64-unknown-none-softfloat.tar.gz=25ac7161cf32dad13f4bcefc64cedb25963f4f61995e9531650c8a2636536263 -dist/2026-09-29/rust-std-beta-aarch64-unknown-none-softfloat.tar.xz=440165cb33ab38c651e798c0ddca0195f36f7ab6de981c37b4f41c98c2cd6f38 -dist/2026-09-29/rust-std-beta-aarch64-unknown-uefi.tar.gz=b5ba39fce8b242d9f77fff252e0da2b4a8d455929d247ffeb522d063eccc3253 -dist/2026-09-29/rust-std-beta-aarch64-unknown-uefi.tar.xz=16915d999525cd8e1488d6378ded9c11f58b0390e2a03f0dfb89d32b3d2339c6 -dist/2026-09-29/rust-std-beta-arm-linux-androideabi.tar.gz=e1d3999e6ba68470df99c7836ce8c51232fb62785ea7c96c6b2a456d468655f2 -dist/2026-09-29/rust-std-beta-arm-linux-androideabi.tar.xz=c23e03c5eea7fc437413e6d539ffdf43bfaf2f00d9f13db2e4d789e3edb31527 -dist/2026-09-29/rust-std-beta-arm-unknown-linux-gnueabi.tar.gz=db082f4b98dd53be4f32b618d5494ec2fc2af75ac571d7aa1e93edba18ecf30c -dist/2026-09-29/rust-std-beta-arm-unknown-linux-gnueabi.tar.xz=cdd51373266d628735f876c8acab3d658f1ec54fca4ef76511c45d7d555d598e -dist/2026-09-29/rust-std-beta-arm-unknown-linux-gnueabihf.tar.gz=62de66b7ac14a2d8b725be25b5f6af6246973ec5557ac631cff594177b1db726 -dist/2026-09-29/rust-std-beta-arm-unknown-linux-gnueabihf.tar.xz=fb86b6e2e3b556a63144c0cef982c200e2bca8d2d0a1db4b1374d0c7724107bd -dist/2026-09-29/rust-std-beta-arm-unknown-linux-musleabi.tar.gz=0f64d408c08361269324e8cea25053c5f542bda8b7afc5393a497808993254ea -dist/2026-09-29/rust-std-beta-arm-unknown-linux-musleabi.tar.xz=b05ec5e82bd8c93ceabbe2578dda16076e4b87daf315dc5baa54c8abd4e52ebf -dist/2026-09-29/rust-std-beta-arm-unknown-linux-musleabihf.tar.gz=2effbb32422491890eb626dcf181cfb30499ba26c4f64d4a96c9e304c22dcde4 -dist/2026-09-29/rust-std-beta-arm-unknown-linux-musleabihf.tar.xz=24bb014666bfadb3256c390b36c2369a324077036eb2cc1c6e2be825d6e8d278 -dist/2026-09-29/rust-std-beta-arm64ec-pc-windows-msvc.tar.gz=932df0b6c8289fb46a9f056b70921a4b1b9400c136dd45c0561f190802d10c1b -dist/2026-09-29/rust-std-beta-arm64ec-pc-windows-msvc.tar.xz=fcf67570a855d2e396f0019492767c8fabf00b20ba614c8e00ee9c987fb06b31 -dist/2026-09-29/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.gz=4805f236f0122d3a67e736031b2b530e9c1c4d7a1cf65039d7118d50985fe033 -dist/2026-09-29/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.xz=3ae97148bbabfee58ecd7db754eef720a084685d6df918713ee9103126f8b96b -dist/2026-09-29/rust-std-beta-armv5te-unknown-linux-musleabi.tar.gz=d5bc909741d6dabf577c4d26e9570e66a4fe0f7a253c61364f57bd3adf11c4d8 -dist/2026-09-29/rust-std-beta-armv5te-unknown-linux-musleabi.tar.xz=6bb41498459ce565e0c91228c41c23ba326cd4d964bb5554866cc350d30d2381 -dist/2026-09-29/rust-std-beta-armv7-linux-androideabi.tar.gz=04be64de9a88dc5fad743c7c9e3ece7ffa88fc8f6741bc7097011dafc3af867c -dist/2026-09-29/rust-std-beta-armv7-linux-androideabi.tar.xz=87450f7a9e275eb7dfd67e78eca210d867ce06e338b8a53eda0e5eebb2930b85 -dist/2026-09-29/rust-std-beta-armv7-unknown-linux-gnueabi.tar.gz=9d2c987cf665bd8490e43e66611cfae292c5bb74aacf7d36129cd71cadfe06dc -dist/2026-09-29/rust-std-beta-armv7-unknown-linux-gnueabi.tar.xz=0533fdb36d2e8ee0b1bf5274e000f7876ade0f6c6a289a4014b97bc41eb4b88d -dist/2026-09-29/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.gz=f6d92ec41459b974d5a1058b079560737261d263f218fa74982fb3d143117e02 -dist/2026-09-29/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.xz=b7ea4246a4a35d36596edba6f808b351abf99e0c861abfc5623d7a7cf2a125e9 -dist/2026-09-29/rust-std-beta-armv7-unknown-linux-musleabi.tar.gz=004e933e4e1cf4c3bde0cb189b22c71bb58e84e9f9d0cab9288d46744c529b7d -dist/2026-09-29/rust-std-beta-armv7-unknown-linux-musleabi.tar.xz=ceed6092180912b2e6bfa95cd7345d2a0da20aced84ef1626ee9945fa109b950 -dist/2026-09-29/rust-std-beta-armv7-unknown-linux-musleabihf.tar.gz=4acecafc1bec8a97b67206557e340d6de7fa3f6a39baef49e704e203798f12b0 -dist/2026-09-29/rust-std-beta-armv7-unknown-linux-musleabihf.tar.xz=b79c57d00374db2f33708752d0c0c1ded34c9282c1a14b7a155f5c8ef49b96fd -dist/2026-09-29/rust-std-beta-armv7-unknown-linux-ohos.tar.gz=2fd30887db6155ef25f02781322e79b6b69113f282e89b68e119677a3cf6c526 -dist/2026-09-29/rust-std-beta-armv7-unknown-linux-ohos.tar.xz=9d65af3b8227e2096f3f78cfa2207241d226ceacd6c5559d2ad682ab156c6842 -dist/2026-09-29/rust-std-beta-armv7a-none-eabi.tar.gz=141612e58714918c93ba2769723712e577c99e19b6d858e77d8677850e2dcf85 -dist/2026-09-29/rust-std-beta-armv7a-none-eabi.tar.xz=2bfe5040c6c62fec4e863428288baa735fc581ac2d7ff4a180b51e169db0f291 -dist/2026-09-29/rust-std-beta-armv7a-none-eabihf.tar.gz=5014575869a7ecf9c6a6c91cb69b97f6fb798d3836f0c1851a5a9128d380fc42 -dist/2026-09-29/rust-std-beta-armv7a-none-eabihf.tar.xz=84dd449ba61513a783e10ccdc4b40ebf02db42a435f306690f945b59a9b38274 -dist/2026-09-29/rust-std-beta-armv7r-none-eabi.tar.gz=bcb61efdf77fc8a3ac756a2989cb29e57519cbba6cd86eac5eed42799e6dab98 -dist/2026-09-29/rust-std-beta-armv7r-none-eabi.tar.xz=0cbdb7ea8c7c9505a3b8a9d055704d736ea9be344862ef3f335d4abc27bf9d21 -dist/2026-09-29/rust-std-beta-armv7r-none-eabihf.tar.gz=422ff4501a710a25cdc6569428320beff61c2840872af2d63dde98543cd795f6 -dist/2026-09-29/rust-std-beta-armv7r-none-eabihf.tar.xz=c26f216ca75b5ab3c9e837a55c6a0faa7ffc3a348125e6dc545def1ad92582b3 -dist/2026-09-29/rust-std-beta-armv8r-none-eabihf.tar.gz=44b08082e62a1469c30956d9b3c82053bf341cd15b36a9ad634d0b9061cb2702 -dist/2026-09-29/rust-std-beta-armv8r-none-eabihf.tar.xz=57eccc6e20abd4d9a95bbe0095401d8b64fca6829e11a0f4f0b4977bd5466b8e -dist/2026-09-29/rust-std-beta-i586-unknown-linux-gnu.tar.gz=c98675485760784593bfcc1c1239ace93b05a90649a37cf40c78ec76f54c9b6c -dist/2026-09-29/rust-std-beta-i586-unknown-linux-gnu.tar.xz=25c25743a6bcbdcf35b6a055b5bb4a7c3af73074bca1923d3b97dfb5b87d51a4 -dist/2026-09-29/rust-std-beta-i586-unknown-linux-musl.tar.gz=5f0a8c43f055eaffe5efe71b62f0ba276bed1afc158efd29f10b5ea064fcd881 -dist/2026-09-29/rust-std-beta-i586-unknown-linux-musl.tar.xz=5d73bfd5f7115ec5e67b07c0e978f4aab9e8f79adee879e917b29e01fb78ca76 -dist/2026-09-29/rust-std-beta-i686-linux-android.tar.gz=7cdb05e049ea8e32fad2cea069fa98181d5289dcb2d6322e5dc80d151ef31b66 -dist/2026-09-29/rust-std-beta-i686-linux-android.tar.xz=e127f07fd97a7fada184bdee50aa83002c7764d6a0b320aa10d6b2bd400b2786 -dist/2026-09-29/rust-std-beta-i686-pc-windows-gnu.tar.gz=3f9713c9e37aafd3ce7c825ccd9a145dd9c975841da6de6f0ce340ae2381ad24 -dist/2026-09-29/rust-std-beta-i686-pc-windows-gnu.tar.xz=ec6e784cd6d3dc3e76857654621a4072193945668287b9d7665eb5105878bf0b -dist/2026-09-29/rust-std-beta-i686-pc-windows-gnullvm.tar.gz=c174dc7ec2ef614eb6323f06e655eb86266c0b81e1d644e5e093d58af7806f5d -dist/2026-09-29/rust-std-beta-i686-pc-windows-gnullvm.tar.xz=ac9f8789b013c8ece9ba57a56bd05047b8b7134c7f3f13e616bca2b592ca5ab8 -dist/2026-09-29/rust-std-beta-i686-pc-windows-msvc.tar.gz=a4b5db143623d75352bab8f5154583b0ee8f3a4886062e9bd79675e956e528d7 -dist/2026-09-29/rust-std-beta-i686-pc-windows-msvc.tar.xz=cfde62235d503f2906d0aeb21a07b479d3765a4d6bff10c1e54fbd557937e089 -dist/2026-09-29/rust-std-beta-i686-unknown-freebsd.tar.gz=d7bbff8b33fd5d247a8bae9a3c83f879777c65651babd1cc7515c52668b0f43a -dist/2026-09-29/rust-std-beta-i686-unknown-freebsd.tar.xz=a22f726246f417641f5feda6ed2622749e375d03d11bb1be57072d74e286ff68 -dist/2026-09-29/rust-std-beta-i686-unknown-linux-gnu.tar.gz=0d90d3e128d0f378c4b8d948fa65e6d3f42c9eda9da023e9218b6d62cb3442d6 -dist/2026-09-29/rust-std-beta-i686-unknown-linux-gnu.tar.xz=5e78729655a70c60fe5c49a32a7f09418a720f7623d512dd260d04ad52645b8f -dist/2026-09-29/rust-std-beta-i686-unknown-linux-musl.tar.gz=1e10e1e648b38e1e5d102ba87c374937ee1eca7abf53d4abf4421c74e2583283 -dist/2026-09-29/rust-std-beta-i686-unknown-linux-musl.tar.xz=a716466a78991384a45d0f27c73a3268e4f1f709d27ea32474100a8cc9ac5736 -dist/2026-09-29/rust-std-beta-i686-unknown-uefi.tar.gz=f5168879aa790d8a823d98865b2abed8683ad998bc46cab8f92b3cb046c0b442 -dist/2026-09-29/rust-std-beta-i686-unknown-uefi.tar.xz=414e0fc0ff74ba42765954390114a14cdfb261dbcf82ffee03509421ac8b13f3 -dist/2026-09-29/rust-std-beta-loongarch32-unknown-none.tar.gz=f651fea2e64f49fb75f74e7b4a350fde8391808ddad903dea20f8af4e4f848b4 -dist/2026-09-29/rust-std-beta-loongarch32-unknown-none.tar.xz=cef214987ba5cff11f8a5c75b11a2bc4fd3be236e23ca98308addbdf83529232 -dist/2026-09-29/rust-std-beta-loongarch32-unknown-none-softfloat.tar.gz=1a2f03ff61944e81dfe485129f96084a8f0843da76ce62287bf6a70500f5644b -dist/2026-09-29/rust-std-beta-loongarch32-unknown-none-softfloat.tar.xz=39f6bd3be80e0ead123e2ac706d5da15e2c76a7fa1994de40817692d82bb7714 -dist/2026-09-29/rust-std-beta-loongarch64-unknown-linux-gnu.tar.gz=5012a90d4f9fcacbdf003f151cd6f3316defcd2283514526102834bbd74a8c8d -dist/2026-09-29/rust-std-beta-loongarch64-unknown-linux-gnu.tar.xz=b8d1bfd9c839ebc6b7c90b98b0be907f6246e69fc92eb48e85db4ed6c7dcbe0b -dist/2026-09-29/rust-std-beta-loongarch64-unknown-linux-musl.tar.gz=6569ec56c5f6fa26aff9883603cb9453504854fee82878b25b1b0d2cc9935e6b -dist/2026-09-29/rust-std-beta-loongarch64-unknown-linux-musl.tar.xz=2b087399ddcface9b4466a915bf99077adbd8849846498016d57a61c48236d5e -dist/2026-09-29/rust-std-beta-loongarch64-unknown-none.tar.gz=064352424fbc4bfb9637b2a5e45c7ac39d4c2acf937a48f5c8b71cc3b24cb615 -dist/2026-09-29/rust-std-beta-loongarch64-unknown-none.tar.xz=1f3bd23cb2fd4444efdbc15637a05ca8adeb18b2dfecdc5281ca92fdab40f6a1 -dist/2026-09-29/rust-std-beta-loongarch64-unknown-none-softfloat.tar.gz=cacb51b0256f0f30722f8b69c4cafaf79dc2e9d561ca4990e00ea450a49626d1 -dist/2026-09-29/rust-std-beta-loongarch64-unknown-none-softfloat.tar.xz=a6c1b71975918d172cf47017a2636a29814297ae79f80d223a83ac0cf17770d7 -dist/2026-09-29/rust-std-beta-nvptx64-nvidia-cuda.tar.gz=e8f0efcb638b971d12ff73cc32422ce944cb2816022dca9d875f1eae938319ca -dist/2026-09-29/rust-std-beta-nvptx64-nvidia-cuda.tar.xz=b40bcea95f0c915cf154ffdcbd1388156c2d3c1734b4b00e192869422dbe170c -dist/2026-09-29/rust-std-beta-powerpc-unknown-linux-gnu.tar.gz=efffecff9289cb117cdf4e3fed6126b45a3a82040e0d5f44101ed52f0b38f274 -dist/2026-09-29/rust-std-beta-powerpc-unknown-linux-gnu.tar.xz=e12f25ed25788772becf9f44bca4e88eda5a1f21cf17f08b09cdfa728f90a764 -dist/2026-09-29/rust-std-beta-powerpc64-unknown-linux-gnu.tar.gz=e032b20d3f989cc8c74478871e6dceed4ce3fe3d0a7d232c15b8976e679f870c -dist/2026-09-29/rust-std-beta-powerpc64-unknown-linux-gnu.tar.xz=82e13804fce4dc6a36832873db80d5a4a43d9d8aee44c40c33c30a88227d5d44 -dist/2026-09-29/rust-std-beta-powerpc64-unknown-linux-musl.tar.gz=20a1312d8c162e7cb26ffe9ba89fa50cc92f4ca4bfa862e3bf2a540d3718a3d6 -dist/2026-09-29/rust-std-beta-powerpc64-unknown-linux-musl.tar.xz=6c2b3f2b17804994388a18f443470049bb63a785852456b27eac2a3320c03b31 -dist/2026-09-29/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.gz=b02de7909bdcfb397a6714fee31031f7039c129fcbf831816d12957217fc9c7a -dist/2026-09-29/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.xz=a8d21a1e9f410be453757ca441d1872cec6a4c92aef1ea2111b4ee4a126a3db3 -dist/2026-09-29/rust-std-beta-powerpc64le-unknown-linux-musl.tar.gz=44be1a79c527831221deedfcfb0e0afd0d8c772102b90286dd9180c6f102dff9 -dist/2026-09-29/rust-std-beta-powerpc64le-unknown-linux-musl.tar.xz=d2305657826fd51a2c6480d8aa3d5fdf92d0f665770a83ee4c0f7f9ed0f0de65 -dist/2026-09-29/rust-std-beta-riscv32i-unknown-none-elf.tar.gz=f1c9e1c8dc22a6f1d784aec5b24922976972c1eeb56e7d587650e22d4eb0d601 -dist/2026-09-29/rust-std-beta-riscv32i-unknown-none-elf.tar.xz=7aaa2bde1cd84c38b13d24dafa47ab9083339795cac996437f41c7510426a562 -dist/2026-09-29/rust-std-beta-riscv32im-unknown-none-elf.tar.gz=f04d393d79727af08de12ca7d13fd41ec78120e3bcc30008f684508edff0f2af -dist/2026-09-29/rust-std-beta-riscv32im-unknown-none-elf.tar.xz=04c8d324b52253354cd7907693bce663b300c075f10a9a0668c29956a8cf8a24 -dist/2026-09-29/rust-std-beta-riscv32imac-unknown-none-elf.tar.gz=2a8d5ffd86d7cf52d942933725653c6147ececd7f19a5d1ffee654a2cd1b8bdc -dist/2026-09-29/rust-std-beta-riscv32imac-unknown-none-elf.tar.xz=5399870b58683f7d4d35b80c7079e959a092ced21e6b56969a9e9c67e82acfde -dist/2026-09-29/rust-std-beta-riscv32imafc-unknown-none-elf.tar.gz=6693b6d5032b92eb844e4c7dfbd7f251dae9a13c8af74aaff015c9258367c292 -dist/2026-09-29/rust-std-beta-riscv32imafc-unknown-none-elf.tar.xz=cd1f07d5a147eb17ff4b6d77a9a9fc567d46a47ec00a1ae15d8ca0d48f12e5bb -dist/2026-09-29/rust-std-beta-riscv32imc-unknown-none-elf.tar.gz=e783e12d4436d0976053f3c559096b4baf6f5a02d222c45f3cb40f59fbb91f53 -dist/2026-09-29/rust-std-beta-riscv32imc-unknown-none-elf.tar.xz=00564a08fd47392352f40d4b375a7ca565c8fee14f553bd526dbd88f049ad9a3 -dist/2026-09-29/rust-std-beta-riscv64a23-unknown-linux-gnu.tar.gz=731b85413ebe28cad585e028bc77b78869e80ee0714f01b5e6a913d452ab6cb9 -dist/2026-09-29/rust-std-beta-riscv64a23-unknown-linux-gnu.tar.xz=25902d5d514f10984a67301e6281b7e7fae38af2d95879c1ae730485068e3d67 -dist/2026-09-29/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.gz=a776dd47f9381e67c9fee75db18df84cc2faf51d8691d23c393ea1514f257bbf -dist/2026-09-29/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.xz=9acd29f728562348bc380cc112cf56709ffd62e499d52e5ac9c0446a8c1731d2 -dist/2026-09-29/rust-std-beta-riscv64gc-unknown-linux-musl.tar.gz=549702f03471fa57abd4b2d990b716fbc87274c8d0386afdc4ccadc7bc4dceff -dist/2026-09-29/rust-std-beta-riscv64gc-unknown-linux-musl.tar.xz=574bd2d37d0c13be91082d9633af161ee3eb7572fd72c8959cc744672723cd1b -dist/2026-09-29/rust-std-beta-riscv64gc-unknown-none-elf.tar.gz=1c52932e910cada292e4561fb2d469d75e48369292475a67221a49e80b06e0f4 -dist/2026-09-29/rust-std-beta-riscv64gc-unknown-none-elf.tar.xz=18c6df09267c26b5f5c3d55b0ca108aeb1c6cc4e286461baef7ad126f5ca208e -dist/2026-09-29/rust-std-beta-riscv64imac-unknown-none-elf.tar.gz=3f42e1e761b319b3e348396c87c3b79f67783081b2ee0acbfcf72c29a5409fc1 -dist/2026-09-29/rust-std-beta-riscv64imac-unknown-none-elf.tar.xz=f5fe44aeb22ad3c00eef4f4a1bac56436ba59bc9336b901d88c0f781032dc954 -dist/2026-09-29/rust-std-beta-s390x-unknown-linux-gnu.tar.gz=88b170bcd8d3e26d422bc8ae7a525d8969878434acdb60c4d8f75ad4a6f5fb10 -dist/2026-09-29/rust-std-beta-s390x-unknown-linux-gnu.tar.xz=5cbcf61ee88f021d7570f360971a4781a48ace118b6c2047a6d71b6928ec874d -dist/2026-09-29/rust-std-beta-sparc64-unknown-linux-gnu.tar.gz=5772cb9750380f03ef47f1502e82ac790237967d7dd2e3de2eaf6fb0fb723df8 -dist/2026-09-29/rust-std-beta-sparc64-unknown-linux-gnu.tar.xz=5f2fcaf8b81c370443b53989dd12f3885c299fd8009aaeefeafb63ffa8c2dc40 -dist/2026-09-29/rust-std-beta-sparcv9-sun-solaris.tar.gz=4bcae41b9149b8d7d3a968b7924fa60ca15ff014c997dffddf1073e3c756a48e -dist/2026-09-29/rust-std-beta-sparcv9-sun-solaris.tar.xz=1bcaae45605a3b9bc05265d48e4bf46bdae9d3a45c6e4cbab4de7df0ec76b73d -dist/2026-09-29/rust-std-beta-thumbv6m-none-eabi.tar.gz=c8668ef20b4a6bdf393082067ec753b9e7e7fdcb4215bfa159a8394e70ac62bf -dist/2026-09-29/rust-std-beta-thumbv6m-none-eabi.tar.xz=6aa054160722c4f887cd335f5e5549afe289f04e7abc5d6df95769a83be453d4 -dist/2026-09-29/rust-std-beta-thumbv7a-none-eabi.tar.gz=b28bd0f5ffebe62f944a3c5f17a9a73eab5c990201ea6961d530b769a69f8d3c -dist/2026-09-29/rust-std-beta-thumbv7a-none-eabi.tar.xz=ce529ebc58e8a757bdab3aee87d34a0c06dd59feca3b708aa97a97b79ca176b4 -dist/2026-09-29/rust-std-beta-thumbv7a-none-eabihf.tar.gz=bc94dbbfe23cf6adf1d34a8a6421480854eab76009a0d327d597f84c83c597d6 -dist/2026-09-29/rust-std-beta-thumbv7a-none-eabihf.tar.xz=96bb2b46a7b11d85ef347e2561730fabd1f56cbb334b5b4ebe8fd0a60fc980ec -dist/2026-09-29/rust-std-beta-thumbv7em-none-eabi.tar.gz=988b9a2c797874a96a155b152d2704624eea46e3ff76c9ee31081708661ee390 -dist/2026-09-29/rust-std-beta-thumbv7em-none-eabi.tar.xz=8c64f7dc6ac9d4b35a5683f6324cff0e1bf136b63dc7b0341f5b15570cd6ff37 -dist/2026-09-29/rust-std-beta-thumbv7em-none-eabihf.tar.gz=35fe10b86edb438efac8d9bb37992dc42758f84b82945fc5c115294c1645e997 -dist/2026-09-29/rust-std-beta-thumbv7em-none-eabihf.tar.xz=9ce5331218676dfe1cee5e975a7e9c56c30e051e4999cf4d7bcc89664aefbb60 -dist/2026-09-29/rust-std-beta-thumbv7m-none-eabi.tar.gz=d268977a2462bc3f8ee3a113965417313c8ce91de44700701bf89a1f485c1261 -dist/2026-09-29/rust-std-beta-thumbv7m-none-eabi.tar.xz=02cc4d5a04d190245b154769f6bf691ad82b2a37d5b6dcff98d25218f4da6508 -dist/2026-09-29/rust-std-beta-thumbv7neon-linux-androideabi.tar.gz=6b5025117edb1c0f6e2a519d7a827c257371bcbfe8c1cd2cf194fd8e808fab18 -dist/2026-09-29/rust-std-beta-thumbv7neon-linux-androideabi.tar.xz=f6ee4b5ee7439a71c1ac02c428ccafd739fb59e4d7743c73218472c99d54747e -dist/2026-09-29/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.gz=a1a6e10b069cc010dc0d25d33e39bf09d2e902ba824951571b1ff6272c406a30 -dist/2026-09-29/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.xz=1e5f603944d9a1565d7ec648298e126a8d039ca8112bc9f5f8c4e6b2bfbe6f40 -dist/2026-09-29/rust-std-beta-thumbv7r-none-eabi.tar.gz=36c4b0a0bfe975883763666d3cc6562ca9f98e1b8623dc6fb1d341390669b511 -dist/2026-09-29/rust-std-beta-thumbv7r-none-eabi.tar.xz=d087749ff3a16e4577ae93afac8635ce614cfd56c68d2f01e939a33ee07ee5c8 -dist/2026-09-29/rust-std-beta-thumbv7r-none-eabihf.tar.gz=fff03b17250ffc7c328b68b542d293da4d81ae16fda76b53ca87d2dbe03a9fd4 -dist/2026-09-29/rust-std-beta-thumbv7r-none-eabihf.tar.xz=e47e298a4f5583c447056566b2c559af073387024d74822d4f7d657396cbb842 -dist/2026-09-29/rust-std-beta-thumbv8m.base-none-eabi.tar.gz=6245b71146c9bf6892f87d36505f8f8b019f925a93e9e7382fb4c11ed7b92921 -dist/2026-09-29/rust-std-beta-thumbv8m.base-none-eabi.tar.xz=1190208ca7e613923db504b2f452c87f631934a9ff69c212824ec15e03a45a58 -dist/2026-09-29/rust-std-beta-thumbv8m.main-none-eabi.tar.gz=e2ae5641572df4bb08906d2b6e7f739eea79278333eb0c5547c49b0727c56dcb -dist/2026-09-29/rust-std-beta-thumbv8m.main-none-eabi.tar.xz=fe005ce3e6d13722a8a20e3ab668d44848ec97a3d7e275b74d60a84d8e421ee9 -dist/2026-09-29/rust-std-beta-thumbv8m.main-none-eabihf.tar.gz=a53f0858a9105a0e1c675d7662838fa849266d19ce5e0f6a35f72e1d3c6d4294 -dist/2026-09-29/rust-std-beta-thumbv8m.main-none-eabihf.tar.xz=f229db4fd00f6995049a9e6e3cec6763dee8ce10daac63bc522013b121bc4973 -dist/2026-09-29/rust-std-beta-thumbv8r-none-eabihf.tar.gz=341a7f6420319fb33970a0904144734539e605a2323dfbf2b91169e53aafdcc8 -dist/2026-09-29/rust-std-beta-thumbv8r-none-eabihf.tar.xz=2f3cebd916bff44147582514eeabe207c693cdd5e058febe7d86e8c5c87ec598 -dist/2026-09-29/rust-std-beta-wasm32-unknown-emscripten.tar.gz=e8b45a1e9bc3b54f1047a1cdaf9f6b8af3a6750413e4da81d69f0590a6137348 -dist/2026-09-29/rust-std-beta-wasm32-unknown-emscripten.tar.xz=5c20fdc9b9429f2cf72b11e31fc401d81a5deed37f7bd15627d81db5f834b57b -dist/2026-09-29/rust-std-beta-wasm32-unknown-unknown.tar.gz=0796808b38d7517a28cfe7ba3eba5ecb037242a9abcc26390e1f1825467c7977 -dist/2026-09-29/rust-std-beta-wasm32-unknown-unknown.tar.xz=44dbce1c52229c875f22d98de17a78260892e4759b996e989d96ca58f22ea89c -dist/2026-09-29/rust-std-beta-wasm32-wasip1.tar.gz=79a9003e337d684054d8c6859c2118da6992f4ac7eeb8bebb790b763294902c0 -dist/2026-09-29/rust-std-beta-wasm32-wasip1.tar.xz=7d0bdf81bdfea1bb40a17055aa3077b0b7afb214a6826a92a462ac9006b6aafa -dist/2026-09-29/rust-std-beta-wasm32-wasip1-threads.tar.gz=1721f8d930563486f9f90572797b910643b4b0d62f1d89f90114568401d3da68 -dist/2026-09-29/rust-std-beta-wasm32-wasip1-threads.tar.xz=dc0968859fba0cf6ac6e2b50cb53b7790529e23e008a8407aeeb72b9939fa2e6 -dist/2026-09-29/rust-std-beta-wasm32-wasip2.tar.gz=f57b56c42f272d0daa2a8dfe5e0dc16d2ec696a820037bffece1cacdb664232a -dist/2026-09-29/rust-std-beta-wasm32-wasip2.tar.xz=e82fa595d0ee89331a1f862efd487beac1d29895f8eb061ad6b6d04049ebdb9c -dist/2026-09-29/rust-std-beta-wasm32-wasip3.tar.gz=6abca32199fc1bd072ef19d69c9884efe3dcb07c81d0260faa0ebb17e94617cf -dist/2026-09-29/rust-std-beta-wasm32-wasip3.tar.xz=f019b8b140d81aa18a01dff20170f07a381908196828870d3b4dfcbe915f9d34 -dist/2026-09-29/rust-std-beta-wasm32v1-none.tar.gz=777b38934c1f0e70e39e2fb55f3424f8dd77c54ad49c72340ba20cd4307d49c4 -dist/2026-09-29/rust-std-beta-wasm32v1-none.tar.xz=4c78b7da12168bb42a4df10aa269b7a5218eb086ad203e093a87c84f64b2756f -dist/2026-09-29/rust-std-beta-x86_64-apple-darwin.tar.gz=232d6824004015f32bbbb285c872030bdaf8bbf36cd259494f24f2802cac399a -dist/2026-09-29/rust-std-beta-x86_64-apple-darwin.tar.xz=63bf0f85ed80e97cac13f2edc54826829867b62b1758565c580a0680bf370bff -dist/2026-09-29/rust-std-beta-x86_64-apple-ios.tar.gz=23e8e77b11c0870bb486fcd76cee15db11587d3f47df20f220d69a46640ddd8f -dist/2026-09-29/rust-std-beta-x86_64-apple-ios.tar.xz=9f556cc01cd4abf0949c23f1ddc4209d7b92cdc1d521cb22403a4258eac0fdb0 -dist/2026-09-29/rust-std-beta-x86_64-apple-ios-macabi.tar.gz=d5e6bd07a5aa5346c1294d851466579d567ce1d1db16f6b9a40c20619958c8d5 -dist/2026-09-29/rust-std-beta-x86_64-apple-ios-macabi.tar.xz=c3d8808f3b17c81d6de7a8ee2486b5a837f67069e51ad29b0a3c2fa4ebaf4f0d -dist/2026-09-29/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.gz=72d8b973a20da182acb65479a067be9b4e8fc4e7f7eed41deeac27f8e2401737 -dist/2026-09-29/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.xz=ec661a7156e6baab75839b55377d270a1151e6c432420683ad5a082571f37a77 -dist/2026-09-29/rust-std-beta-x86_64-linux-android.tar.gz=06c09a6a5e54e4da413cedcf0a178107f2d6cfc8082903b262a5db6c807b4a44 -dist/2026-09-29/rust-std-beta-x86_64-linux-android.tar.xz=d36c4d48fa72b2313ba29fc757c505e8a11c712cc779eda7ffa5062b2646907e -dist/2026-09-29/rust-std-beta-x86_64-pc-solaris.tar.gz=ca8ce15a7ae374cc46fde55808a54f94c197bcc9bb40448df06e09cef1257dae -dist/2026-09-29/rust-std-beta-x86_64-pc-solaris.tar.xz=f7c2208dec2c25805546258a81d361f250672ea51e0891254bee9f3c3f4e95ff -dist/2026-09-29/rust-std-beta-x86_64-pc-windows-gnu.tar.gz=b8632646f82535baf39460a3a6ed6a6a92e33f31787efaaf4e6d655225c4f5a8 -dist/2026-09-29/rust-std-beta-x86_64-pc-windows-gnu.tar.xz=ab6729530be4e5fbfa51e76f53f4dcf9c974e0ce6ed11556e8aeb831b1aecdc6 -dist/2026-09-29/rust-std-beta-x86_64-pc-windows-gnullvm.tar.gz=c76571599f894548491d95639bd75f551a3c614e8dfcf34dc6b38e1d3bf28474 -dist/2026-09-29/rust-std-beta-x86_64-pc-windows-gnullvm.tar.xz=52dcb526a8ddeaa6081809401ff94a733128a5e4adf9feb1671744ca1134d817 -dist/2026-09-29/rust-std-beta-x86_64-pc-windows-msvc.tar.gz=84c55c99e3a783136cd334db0fcd6cb6e6cc6d3fa997fedc87dd7620e094ca5d -dist/2026-09-29/rust-std-beta-x86_64-pc-windows-msvc.tar.xz=d7c46a39c354ca67f2197be455db7f3817cf35f476b8fac5c85e16c911cd291c -dist/2026-09-29/rust-std-beta-x86_64-unknown-freebsd.tar.gz=46331daca0d7bc83edd687190817d7b7b62f14fa037d9dd56c32314d10e1df29 -dist/2026-09-29/rust-std-beta-x86_64-unknown-freebsd.tar.xz=ac315cd71f957e6b555f98e7744bedf32ae06cecf8a688594d16dc11b0409e14 -dist/2026-09-29/rust-std-beta-x86_64-unknown-fuchsia.tar.gz=5ac6db26e1298837d5d660ca24be108c9fe569784ddb2061dd8b7afca06c4a1a -dist/2026-09-29/rust-std-beta-x86_64-unknown-fuchsia.tar.xz=0ccc6aa8a3746d143515882a33254fa67cead1e58fc3dbce191769f59fccb635 -dist/2026-09-29/rust-std-beta-x86_64-unknown-illumos.tar.gz=9547382b596806f8460bffd1fba4b21c87a809744b678d1379c821288256bfb7 -dist/2026-09-29/rust-std-beta-x86_64-unknown-illumos.tar.xz=a52fa0165572f08d7c0807b618b8841c9220065ff188095bdbf4bd4e9bb11771 -dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnu.tar.gz=b8eaac057b7b4197941904f539ef4e01eb93daeaedd8b158b5a0a2d8e370ea26 -dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnu.tar.xz=9095fa52e354f1441568af9e3a9839b16268f7ae7707fd4bc48b2a2bcd1d547f -dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnuasan.tar.gz=956b82298d2f2c7e34e28d157ba41945d39865a23b9bbe20678d7ae31aa825b2 -dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnuasan.tar.xz=3ecf190a1c53ee9aea39f643ac62923835379f08f6503f4134459ebc5f610a08 -dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnumsan.tar.gz=10576f120a98f153c7a68e62a565a92424917a36fe3cb017f4a657e236b3ff88 -dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnumsan.tar.xz=a009b119cc0d811e070dc329cf241b8b509d9a297faa68c5d2216b4e21f5ac50 -dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnutsan.tar.gz=8d9aab19bea2b6b07f11e9a2bdc0058441e6f80f4d6e778c03cb5b52854c7aca -dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnutsan.tar.xz=3507d9b8563db110eaae0253c5c041b62d42508696f1526b94b92fd28e200b14 -dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnux32.tar.gz=7dc3b370335b15345dc9f508c4f132d00a69fdf0feacbaaaaa2f93bd7cbf9ce7 -dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnux32.tar.xz=b8b24db68ff29f15c52fc70ee12cc6d10bcd65259c521876fb08892c8f67b980 -dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-musl.tar.gz=13da2b408f85665b37c6ba519cc4fbf8eeacae1dd6835f22edd800fa229d6f56 -dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-musl.tar.xz=61f986574cf89a091fc6563c0cef458e1c5618444364eb36751194b2da7f8da9 -dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-ohos.tar.gz=48d5e6ffa8dc7319809a13ed109a8c5e43e9b17d5e6c9e88a57ec160068caae5 -dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-ohos.tar.xz=962cc03687830996b02c8419b4f948b94b7f9b6c40a918212bfa9ba8a3186aea -dist/2026-09-29/rust-std-beta-x86_64-unknown-netbsd.tar.gz=93c518fd23ffc00d69f37e38b90033d76091b3946ee7ec82d906b78a4f7130e9 -dist/2026-09-29/rust-std-beta-x86_64-unknown-netbsd.tar.xz=a8922fe96c323e6ccf587a70841651143065e25d2ce465dea5e2d9ffb52fd42c -dist/2026-09-29/rust-std-beta-x86_64-unknown-none.tar.gz=4df5d869a75e754e1952b73fa78a4722fca53038325dd0e541887e8d0c8a7620 -dist/2026-09-29/rust-std-beta-x86_64-unknown-none.tar.xz=c37467acf1d25eaba261edff55a410a0104dd31b90f8158b10b6f2e369a6d9eb -dist/2026-09-29/rust-std-beta-x86_64-unknown-redox.tar.gz=8d245bade3f0fd036e16314190cf3a0ca535c75a4c97277e24135a9e76815156 -dist/2026-09-29/rust-std-beta-x86_64-unknown-redox.tar.xz=76392bc2afdd60a591b3114fb191deacf59388c21fb1d7ec1733f2f561778648 -dist/2026-09-29/rust-std-beta-x86_64-unknown-uefi.tar.gz=b17e48ee19a86057a7ebaeadd697a4dc86853cf9e66c4981e5043de9e3ce1c00 -dist/2026-09-29/rust-std-beta-x86_64-unknown-uefi.tar.xz=1cd2a4b32284ffb4d11bcd3fb561578f3d00c763c704a177e113af6899c22d0d -dist/2026-09-29/cargo-beta-aarch64-apple-darwin.tar.gz=f3066c859807c0ab69429ea69362654e18c21d26b2c482be436280bfad4b49e2 -dist/2026-09-29/cargo-beta-aarch64-apple-darwin.tar.xz=0bdc913f85f762ca2af5c9bd2d72a31865c102bc66bcc43250a7eae06208de49 -dist/2026-09-29/cargo-beta-aarch64-pc-windows-gnullvm.tar.gz=e2bde3311142eee8c4d822ff838778cbd2ef7d7f496f4dd4a0237756fd16964e -dist/2026-09-29/cargo-beta-aarch64-pc-windows-gnullvm.tar.xz=1c26e80d1529c17cf4ef6025ceb63490cd862ca9eb7c21fa043fa89d2ee1f0ff -dist/2026-09-29/cargo-beta-aarch64-pc-windows-msvc.tar.gz=2b71fb86fb57894c2fa83ae53522783fd9b5b654332ae7623eca3b153f4136e8 -dist/2026-09-29/cargo-beta-aarch64-pc-windows-msvc.tar.xz=5a8b4e3db041cafd58e59333f872cb1020f385d54269ea02ca7ca8a4ce45796a -dist/2026-09-29/cargo-beta-aarch64-unknown-freebsd.tar.gz=12d98333d9d48a97a6cf0bbb9b01cd4a215a51feaf81c5ddb4ac54ce3644814b -dist/2026-09-29/cargo-beta-aarch64-unknown-freebsd.tar.xz=89fc6ebdf93d553fc957a1adac94f9d83feabd5c84c364aa875f36a4d274e31d -dist/2026-09-29/cargo-beta-aarch64-unknown-linux-gnu.tar.gz=173043d8b96bbd8149de521da3271123895af497379a278a87039cef644f5245 -dist/2026-09-29/cargo-beta-aarch64-unknown-linux-gnu.tar.xz=69eae56c755c9d90a1e35d38e22d43b46e204913d237c5c2ea9001906a273db5 -dist/2026-09-29/cargo-beta-aarch64-unknown-linux-musl.tar.gz=2590e51b526f771cc486a2ca15f89c7ccdf878bce18c7e03cf32b6116ab5483c -dist/2026-09-29/cargo-beta-aarch64-unknown-linux-musl.tar.xz=8d1325965495214ac2894aa9062255e519397eded66a32e71b871eeea81dd930 -dist/2026-09-29/cargo-beta-aarch64-unknown-linux-ohos.tar.gz=e18bfa187c668f15f48aa36fcb29d71791577132e829334dd3ac05d5b7cdd7f4 -dist/2026-09-29/cargo-beta-aarch64-unknown-linux-ohos.tar.xz=fc3d7339b87792efe262f8f0685bc97c42bda4ee21541d4d0719e1ba1fdba4a5 -dist/2026-09-29/cargo-beta-arm-unknown-linux-gnueabi.tar.gz=25a23eaf8af21d465d2b0ca6461281702c10339d968ff226e0c63dc6bf9950ae -dist/2026-09-29/cargo-beta-arm-unknown-linux-gnueabi.tar.xz=7544dd758d44668e985e93eb777bccead5f63bf98326ed7e003d2a68a59d4c4f -dist/2026-09-29/cargo-beta-arm-unknown-linux-gnueabihf.tar.gz=016d2a04723930c835f7564bbf460978ec2ba9f497c5b94c6665ece36989aefd -dist/2026-09-29/cargo-beta-arm-unknown-linux-gnueabihf.tar.xz=4a40079a253cb349e41148b919b7e460e5eb6c659089dc4366c32cb343dab5c8 -dist/2026-09-29/cargo-beta-armv7-unknown-linux-gnueabihf.tar.gz=36b8677ec6fc857af1777e2f4a68c2cbe90a72b21f9afe2b4221593a76cd3748 -dist/2026-09-29/cargo-beta-armv7-unknown-linux-gnueabihf.tar.xz=816e1c6b3bdaf08b24514331b972d864a6b7bd8d63479fd154dd1608ac66f26e -dist/2026-09-29/cargo-beta-i686-unknown-linux-gnu.tar.gz=f374e9858d5d4294e9007986d4df7af0d15a57bef5862c289b818c3bf7bc8299 -dist/2026-09-29/cargo-beta-i686-unknown-linux-gnu.tar.xz=ebaa11b6203e20cb0a612c53aaa9a0ae5c275795c1737c4bebebb679cdabb485 -dist/2026-09-29/cargo-beta-loongarch64-unknown-linux-gnu.tar.gz=e6816ee73290cf376b402ad6470eb2b68004a883b1b4294393a8966d7bdf1aa0 -dist/2026-09-29/cargo-beta-loongarch64-unknown-linux-gnu.tar.xz=b476bcd327cd838606b8482381c6fabf0ce97f518e3ab11b35a50827f2b18b51 -dist/2026-09-29/cargo-beta-loongarch64-unknown-linux-musl.tar.gz=b83080fee58cb9e72db9c8ac994724ff3a5bd2b7039eabbfa0cd9bc77d2d4532 -dist/2026-09-29/cargo-beta-loongarch64-unknown-linux-musl.tar.xz=889717547ec4cbb80d7f2d2e35b1b2b512c3e450ffa56a1bc27289fe285898d6 -dist/2026-09-29/cargo-beta-powerpc-unknown-linux-gnu.tar.gz=340d7ff13760dbb32148c8616dd7c7246870a7f091bda102902589a20dc8c2f0 -dist/2026-09-29/cargo-beta-powerpc-unknown-linux-gnu.tar.xz=29c10897c335e4bd2dde7848bf67bcc93b96e5911888524d0abb8704fb88a629 -dist/2026-09-29/cargo-beta-powerpc64-unknown-linux-gnu.tar.gz=62fe339183294cdd58c5c90a6a1dff3a388dc2b054f2ef46babc127cb1dcaf11 -dist/2026-09-29/cargo-beta-powerpc64-unknown-linux-gnu.tar.xz=18ce8044103b232c245c8ad3ab92073a473740a897506c69f79c406b611263d1 -dist/2026-09-29/cargo-beta-powerpc64-unknown-linux-musl.tar.gz=fa3e4a74e3bcb12816049d51dcbd9103fd2136679c509b47b4a64f38686c46d9 -dist/2026-09-29/cargo-beta-powerpc64-unknown-linux-musl.tar.xz=d5efafc560f206af8e32d6a720c923e74443af1e5e30e8e9a5a06a38b2955534 -dist/2026-09-29/cargo-beta-powerpc64le-unknown-linux-gnu.tar.gz=07a1eb729d565b322c3f65d925cb98f125d8c031ea390e5537208fc831cdb627 -dist/2026-09-29/cargo-beta-powerpc64le-unknown-linux-gnu.tar.xz=fae744722b6f92d00dcf4325d1f5c7a59dbf3563f53318e772ac48ec330c7d2c -dist/2026-09-29/cargo-beta-powerpc64le-unknown-linux-musl.tar.gz=95e91adc5af521f58650ab88707c870952be0492e913c96df8dd3a816449f242 -dist/2026-09-29/cargo-beta-powerpc64le-unknown-linux-musl.tar.xz=d46a64931a0ff96ba7c80f3fb3edceee803d86458c72255b5037857e0ff86de5 -dist/2026-09-29/cargo-beta-riscv64gc-unknown-linux-gnu.tar.gz=05a6b30d13367ee0f13295ebad1ab19c41d6ef7e0658971b4857e2b423d04ac2 -dist/2026-09-29/cargo-beta-riscv64gc-unknown-linux-gnu.tar.xz=d64db7e154194aab5d689236a545e3a2f657a67339c0eff77581be6f1808e6f1 -dist/2026-09-29/cargo-beta-riscv64gc-unknown-linux-musl.tar.gz=88adb1c494bc36bc577bb13bae1efa5051481cfce96249c4d340ab7eca017c17 -dist/2026-09-29/cargo-beta-riscv64gc-unknown-linux-musl.tar.xz=8347b2a940db92e3af2c11208ad77c337f5dc856960656c179e19c2b17a161b5 -dist/2026-09-29/cargo-beta-s390x-unknown-linux-gnu.tar.gz=79070ab2fd6d93d37a1cdd11d24a1de15a887d5503086f1e64766a99796decb3 -dist/2026-09-29/cargo-beta-s390x-unknown-linux-gnu.tar.xz=b64e4cca016d3ffce2b1e6944cd249d4e93eab689c0d9cced01a798bc7e183e9 -dist/2026-09-29/cargo-beta-sparcv9-sun-solaris.tar.gz=fc1bfe106843c3b7f0affa77de936dfdb8b9f5a438176d9037aa0533e9b9c8ee -dist/2026-09-29/cargo-beta-sparcv9-sun-solaris.tar.xz=9e12971574167eff3830526f10db3e21cb817f4b28acdb10c42c7689cc2f9656 -dist/2026-09-29/cargo-beta-x86_64-apple-darwin.tar.gz=97072e5a8006d0a8932983a44b1dc0a7b56d46efc76fac6378315f43cfb2c556 -dist/2026-09-29/cargo-beta-x86_64-apple-darwin.tar.xz=d296336efa8cee66a03655cbd66e64709866fe98bc2aeabfdff88039b74eb800 -dist/2026-09-29/cargo-beta-x86_64-pc-solaris.tar.gz=96832f53757943d1c752dadb11fc122af8085317017d7263b73d413029ce9b1f -dist/2026-09-29/cargo-beta-x86_64-pc-solaris.tar.xz=091cd84168e3c9dd860bc0df58d07def0318e470c3459cd431fed713c0ab2616 -dist/2026-09-29/cargo-beta-x86_64-pc-windows-gnu.tar.gz=f99a145aa7938be5baae99302858b680e2c2ae3dd84e8434cc38de374967deaf -dist/2026-09-29/cargo-beta-x86_64-pc-windows-gnu.tar.xz=5bd7758064d9500c68fcfdd5a3a851d4dda40d3c870a83b9a70c93b46a8c8823 -dist/2026-09-29/cargo-beta-x86_64-pc-windows-gnullvm.tar.gz=06494aceb50c8bf0131639c52c62746b07ff2143b04d383be6f137277397a0ae -dist/2026-09-29/cargo-beta-x86_64-pc-windows-gnullvm.tar.xz=5923b97ac130c29f6f0ba96fdbf4b034a452a9d03ae78d8bd812e9d3eb304a80 -dist/2026-09-29/cargo-beta-x86_64-pc-windows-msvc.tar.gz=26736efdd0b4e09dd8e7ed421881fcd39e588b31c45129c011bd78d83e42c153 -dist/2026-09-29/cargo-beta-x86_64-pc-windows-msvc.tar.xz=9e72a3172d9638143bbb51c9cecfce7dfbe463644ca3e90cfbfb04a30561ed93 -dist/2026-09-29/cargo-beta-x86_64-unknown-freebsd.tar.gz=e9b9ecfda5fa944168f81c12ebbe2c127ab245f867d61d47197ae23ca8eb9c86 -dist/2026-09-29/cargo-beta-x86_64-unknown-freebsd.tar.xz=e7359e4d2a6e0ff4ac99fa49346f1e2ee4c64487bb2f35ef0b75fc497bb676bf -dist/2026-09-29/cargo-beta-x86_64-unknown-illumos.tar.gz=bc5382bc1853388dc1573f464bfc3393f41293b159826488b0096ce1dd87582a -dist/2026-09-29/cargo-beta-x86_64-unknown-illumos.tar.xz=46867f0df7b6b95f13598267c5e17a96aff1de929ea2b23fbedb30e7b24324da -dist/2026-09-29/cargo-beta-x86_64-unknown-linux-gnu.tar.gz=dc8dcdee80d7034b0ceadb64fb15608c7617022f4c0be595bffed3326f1bc7a8 -dist/2026-09-29/cargo-beta-x86_64-unknown-linux-gnu.tar.xz=6ed534d029be58d7c0fcebaba581166fee81167de58806540d9d6ffb0f68836d -dist/2026-09-29/cargo-beta-x86_64-unknown-linux-musl.tar.gz=ccace12c5ac38d428e107faf94c7945eeff7f72058910fe93f6514234feb0aef -dist/2026-09-29/cargo-beta-x86_64-unknown-linux-musl.tar.xz=03501cfc18b5dd937612ee76fbd57ded962da245f87aefe3bfa4f332afd9812f -dist/2026-09-29/cargo-beta-x86_64-unknown-netbsd.tar.gz=384f90d70932ba9babe4f9baae008cdf52ef7815a0052b7b6c73bece3f024aa6 -dist/2026-09-29/cargo-beta-x86_64-unknown-netbsd.tar.xz=3c4e43e90a741f1e10409b3cbe426ebe3d3506ad7196eb291c55c4ee060d9e19 -dist/2026-09-29/clippy-beta-aarch64-apple-darwin.tar.gz=aa278ec430f7939b2eb5da177a7e3229b92105ee9e7ad71d8ba7f04cf6f41a4a -dist/2026-09-29/clippy-beta-aarch64-apple-darwin.tar.xz=3929ed842657b6792f95b987e0deb630d96aeb98db9700493be148999390c5e7 -dist/2026-09-29/clippy-beta-aarch64-pc-windows-gnullvm.tar.gz=1272823dc9eeb737f03ec09313c09953d75fea3a848e695c8bc434c2ab53e062 -dist/2026-09-29/clippy-beta-aarch64-pc-windows-gnullvm.tar.xz=76155e48b475fc40bb31ad136725f00875385db2bf179fdb3979065c7a65282f -dist/2026-09-29/clippy-beta-aarch64-pc-windows-msvc.tar.gz=f79d2073573010aa0f1ee4a8579b17f3a1997dc96fc6652a8c8c19a566231eb0 -dist/2026-09-29/clippy-beta-aarch64-pc-windows-msvc.tar.xz=4b8303804318d731b61159959c93782f205a95d8a3aa14e1643b319b6fe9558e -dist/2026-09-29/clippy-beta-aarch64-unknown-freebsd.tar.gz=1028922c743c9170603eb76731be0d3d994873a2b5a47f6a46480eb339a14554 -dist/2026-09-29/clippy-beta-aarch64-unknown-freebsd.tar.xz=ac262e022b7b09669051a325e02eef2cb83087c25ffdee6f059e2069ef430e3f -dist/2026-09-29/clippy-beta-aarch64-unknown-linux-gnu.tar.gz=bb1376c0de000c1e0efdaf8ecb9fa11b14a64a6fe99000ac391f828376ce2c12 -dist/2026-09-29/clippy-beta-aarch64-unknown-linux-gnu.tar.xz=90d1d3895d777b2a473f8035d3264f374c9ca91fdeec32d78899ae0a5f33f0ad -dist/2026-09-29/clippy-beta-aarch64-unknown-linux-musl.tar.gz=5a4cd4fa995f9ba8ef4f87001a87595c4a144f1af62b6a61ff2c5d4e2d90f7aa -dist/2026-09-29/clippy-beta-aarch64-unknown-linux-musl.tar.xz=3775b95f01258fb108f323d031ba8920993d23746f62a6fe5b14add176833b05 -dist/2026-09-29/clippy-beta-aarch64-unknown-linux-ohos.tar.gz=7759e690dcf0984c274dadb14d5601f64cecd21c833b44c93b24c509234bd697 -dist/2026-09-29/clippy-beta-aarch64-unknown-linux-ohos.tar.xz=21598de0d56cb2c0a259cec74bf4b45b1ae350a9d62296289e85f6648fff0427 -dist/2026-09-29/clippy-beta-arm-unknown-linux-gnueabi.tar.gz=a8db1b3308fd0764012d3e76bdf92a076749a04af6f3f139288a1b5f7aea6d3a -dist/2026-09-29/clippy-beta-arm-unknown-linux-gnueabi.tar.xz=746e5b548d3c57a9c42da80a02a5c2df0c2e025b2a8becf17ca1aab937d0bf27 -dist/2026-09-29/clippy-beta-arm-unknown-linux-gnueabihf.tar.gz=6100df771233dbe2d31b9ca7ac202ecdefddb964687b9ea2b97799c58f2df8b1 -dist/2026-09-29/clippy-beta-arm-unknown-linux-gnueabihf.tar.xz=601693ede0315db0d92c6bc9c53f1f4d829d1a506001cd291fcb61c12c91ca09 -dist/2026-09-29/clippy-beta-armv7-unknown-linux-gnueabihf.tar.gz=a7cf7145fc885a7d0359e6f32f8d9a46bf2adbdf268823f1202647bc2a131fdc -dist/2026-09-29/clippy-beta-armv7-unknown-linux-gnueabihf.tar.xz=4b26189ee6eb3d78cce60be7a54d0d64f1a5bfb18dbabf30e829296ee09065a6 -dist/2026-09-29/clippy-beta-i686-unknown-linux-gnu.tar.gz=b73fe9b224653599b38a0a68cada53106276e749f5350871a1d549be5c147487 -dist/2026-09-29/clippy-beta-i686-unknown-linux-gnu.tar.xz=60fa35754a88f0f97e538b639c24237d651c11e1edb16c653536111e1a7f123b -dist/2026-09-29/clippy-beta-loongarch64-unknown-linux-gnu.tar.gz=8a59dd0ce10cde5e714d3f8989fb1ebde1ac51d746e96a72d6239feae81d1568 -dist/2026-09-29/clippy-beta-loongarch64-unknown-linux-gnu.tar.xz=3e7d0761021dc58612054a575e202224645665f90fec0bf805998694a71c8fb9 -dist/2026-09-29/clippy-beta-loongarch64-unknown-linux-musl.tar.gz=f220e05c95906dfe8247ab7a3fb732a5444cba27facad044f50db4c04b62bff4 -dist/2026-09-29/clippy-beta-loongarch64-unknown-linux-musl.tar.xz=d9a7343dd0ee670a086a565a1013f647b3fd8061d4594d42cd2724d3cd52bb78 -dist/2026-09-29/clippy-beta-powerpc-unknown-linux-gnu.tar.gz=e025c6f5c822b45ddf5387dc9a42dcdca9f69be2546a020b2d4de2c07590b8c4 -dist/2026-09-29/clippy-beta-powerpc-unknown-linux-gnu.tar.xz=90d7b50a45274903c43d4d1c57c9ed5b4213c07563feed70caec38723df02bbf -dist/2026-09-29/clippy-beta-powerpc64-unknown-linux-gnu.tar.gz=31aa57d681a3215023de663aafeea01e476be4e2a1f89345602e89eb3b1b5c03 -dist/2026-09-29/clippy-beta-powerpc64-unknown-linux-gnu.tar.xz=fc5dd5800afb155af741770c6111262e9a2b5817bbd8bc2ba06ba2daeb72c822 -dist/2026-09-29/clippy-beta-powerpc64-unknown-linux-musl.tar.gz=ab5edc689617c105a00941d3870b6490c62209d235d09b7f2d48b8ca460b62a5 -dist/2026-09-29/clippy-beta-powerpc64-unknown-linux-musl.tar.xz=77b9759b82d634222650a2ccf9160b654fc636be0b7fd4fac822728eaf1f7317 -dist/2026-09-29/clippy-beta-powerpc64le-unknown-linux-gnu.tar.gz=04f40458440c4222e49df829159f51fc667c10b0762181a535ff61cf120352be -dist/2026-09-29/clippy-beta-powerpc64le-unknown-linux-gnu.tar.xz=ebc8495543e025b2c6db795f665725ad62a2ddd17094f6725bf4e00cbbf25331 -dist/2026-09-29/clippy-beta-powerpc64le-unknown-linux-musl.tar.gz=ba6653802d14bd1586819ae5f9510b9a97e0ba6ebc062942264b52fc297fcff8 -dist/2026-09-29/clippy-beta-powerpc64le-unknown-linux-musl.tar.xz=7c3f65a1938dea882cfee18992a10cb23b58de801a191d0cbbf8c6cc6f9cd900 -dist/2026-09-29/clippy-beta-riscv64gc-unknown-linux-gnu.tar.gz=ad43d2a294308b1509151379c5a9bb40b064e13a841c2d34ed31537bd9eda3a0 -dist/2026-09-29/clippy-beta-riscv64gc-unknown-linux-gnu.tar.xz=d7f118d124d772ebe763780f8ab1cd0295562eccae944c5507500971eebc5352 -dist/2026-09-29/clippy-beta-riscv64gc-unknown-linux-musl.tar.gz=9bb458f695227868c03d21e15177210b067c7fea223c1ba877f3908cff85e673 -dist/2026-09-29/clippy-beta-riscv64gc-unknown-linux-musl.tar.xz=80de4f209ad908cb28921bedd07cbb1444cd7f25179a851c6a2285bfcb13e13e -dist/2026-09-29/clippy-beta-s390x-unknown-linux-gnu.tar.gz=1f3e61cac84317586d80f816465800299920d032548dc82ac6fdd554503d9f86 -dist/2026-09-29/clippy-beta-s390x-unknown-linux-gnu.tar.xz=98f16b6b0a8a6a4542a07d0ec06ae1a05cefdeacfe7398363c61af5b5ea0e3dd -dist/2026-09-29/clippy-beta-sparcv9-sun-solaris.tar.gz=d5876205c3b704883a464354e287ad485dd0677261d36c7adb3beb97509bf907 -dist/2026-09-29/clippy-beta-sparcv9-sun-solaris.tar.xz=b036fc21fa47b8bce0113a1ef74ff869a54ea06d8f3bc0058f4551c3daa1f089 -dist/2026-09-29/clippy-beta-x86_64-apple-darwin.tar.gz=d9f9860fa397ae78d9e6612240a05eedb917cf536ebdef03bfd4bee110feff58 -dist/2026-09-29/clippy-beta-x86_64-apple-darwin.tar.xz=b054e2bba8ea8b3994e48aa1ef9b121eb1760f1c9468da3dcd9ca8cbe05728b9 -dist/2026-09-29/clippy-beta-x86_64-pc-solaris.tar.gz=ab47ad303b93eae7fd933333a94e7b4f65f0119735b83b8eca83691e24f982bf -dist/2026-09-29/clippy-beta-x86_64-pc-solaris.tar.xz=2187367acea68f7bf09932f0cdb237e30e57a57aadcc388219f60aaf28ec4ea1 -dist/2026-09-29/clippy-beta-x86_64-pc-windows-gnu.tar.gz=97af8a6c3356b4d65d1f96f893e57100969ecfbb2e6c364a2380b07d154677ec -dist/2026-09-29/clippy-beta-x86_64-pc-windows-gnu.tar.xz=af7f0a59d0ae24d0dc8ab6424a781a65d5d0cb8b3253786daa908e1d43efa7eb -dist/2026-09-29/clippy-beta-x86_64-pc-windows-gnullvm.tar.gz=683647b7e096c4085162b0936c614e7151bd6e9e6c5da902a80e68b91d54f47a -dist/2026-09-29/clippy-beta-x86_64-pc-windows-gnullvm.tar.xz=9a3b7efc7dd8c84f8351f117bcad61423c2f2cae6c1782fd28361a6865d31abf -dist/2026-09-29/clippy-beta-x86_64-pc-windows-msvc.tar.gz=b487c66b5091b4a7446f70d9fe138b62a253aac4a8a7745151f8a2e0f0af2c77 -dist/2026-09-29/clippy-beta-x86_64-pc-windows-msvc.tar.xz=53c63e23c797c931401bfc23053b336ebb0e0e26d603cd817770daff8aa8fb8e -dist/2026-09-29/clippy-beta-x86_64-unknown-freebsd.tar.gz=1174a56bb2aab0c5f88b963a8d2d26fbb5d29ff3f3dab449c6848711641060c8 -dist/2026-09-29/clippy-beta-x86_64-unknown-freebsd.tar.xz=adbb076f2efe0532c7e6997ceab6c08e8e5c228774b0e9f844bc238c14663f90 -dist/2026-09-29/clippy-beta-x86_64-unknown-illumos.tar.gz=07047d9cf9e20e6cdf12f1a24706eaf6791d921df97430aea8a1fe37f6cfd6f1 -dist/2026-09-29/clippy-beta-x86_64-unknown-illumos.tar.xz=7720a8410c6c1814a60c9c1432190179aff2bcdba720cc1fe7863cfe9c4ef7e2 -dist/2026-09-29/clippy-beta-x86_64-unknown-linux-gnu.tar.gz=9a47312d7f06050e2a35f884a0fadb63994d9ce4c988db7055df9c3a18826db5 -dist/2026-09-29/clippy-beta-x86_64-unknown-linux-gnu.tar.xz=dc6cafdb56fa4c08d69fabb0fe55c2bfbd13f5452676b7ca7ea80b0feb0636b7 -dist/2026-09-29/clippy-beta-x86_64-unknown-linux-musl.tar.gz=681bc45997f340b2767e1fcdb98d77cd6331b435c0b9b94d3dae0d68d2afe628 -dist/2026-09-29/clippy-beta-x86_64-unknown-linux-musl.tar.xz=09933240e021562422512f9a01364a681fa5fbdc0518d53b2c84159cc160f64b -dist/2026-09-29/clippy-beta-x86_64-unknown-netbsd.tar.gz=7f09a6e7d2a3ca645d600f7b2836854240927b9b22ed5b90c2e19b18602f1bf9 -dist/2026-09-29/clippy-beta-x86_64-unknown-netbsd.tar.xz=6f55faa86ce658f28036f4828d00d9f3554a16bc4c08d338f90e46cc0b8290a8 -dist/2026-09-29/rust-beta-aarch64-pc-windows-gnullvm.msi=110b7787e72503c3d8f00bb83b4844ee5d86282006535978fabaeccd570b9446 -dist/2026-09-29/rust-beta-aarch64-pc-windows-msvc.msi=52095c3b2bb30c4444514adb315c441ae99a908fcd6dabf84df86e9fa547fdf2 -dist/2026-09-29/rust-beta-x86_64-pc-windows-gnu.msi=0dbeb0a4874799e29f61078c2ee7b52aa09f3892da449949562f7b834213d2af -dist/2026-09-29/rust-beta-x86_64-pc-windows-gnullvm.msi=67bb2a3bdf0efa223c1ec3961ca8bb3becd0dfec3dbba6c1664f3800c13f96c9 -dist/2026-09-29/rust-beta-x86_64-pc-windows-msvc.msi=f3832ded2d7dc6b8e344a8a05a58145753b7206409ab7989e4e175b000891bb5 -dist/2026-09-29/rust-beta-aarch64-apple-darwin.pkg=ba8205d70d4e7d9dac9fcbbb50e26a1c48d95f6d53115cd4f31b4894fb770f86 -dist/2026-09-29/rust-beta-x86_64-apple-darwin.pkg=821a0c24ed40c517f6b3cadc591a41e12f3dc17ee177d304d91adcc4d00d1557 -dist/2026-09-29/rustc-beta-src.tar.gz=1e970d860c77112674c08a4f6fe27c7f5f3eabdbaaabae7924872f37b0a6bc9f -dist/2026-09-29/rustc-beta-src.tar.xz=8c8dd7643b15e160e0ee62ce2ea2804c1c463954a983527335c9ad05e2d7a282 -dist/2026-09-29/rustfmt-nightly-aarch64-apple-darwin.tar.gz=3bd82067ee57ab38a80d21b212397e600b1cdfac4ffe67e064a0d4fc72696579 -dist/2026-09-29/rustfmt-nightly-aarch64-apple-darwin.tar.xz=105657de7a7e2989d0e1aa27655bad89689dfa702e6208072c04a5dc1f116dca -dist/2026-09-29/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.gz=e9ac24651a2dcd1b92c85ce3ca537ca4004d077d13d81a76c30543a2ff537ce8 -dist/2026-09-29/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.xz=12d0fed0b8caaea2fb0b63590a4dc2f96af71a54eb3ca113e09601a5e603fa7e -dist/2026-09-29/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz=2e4a7ba18c433714efdcce7b1b858a3128b10918f0b6c081225b5699ce095b4c -dist/2026-09-29/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz=da5ef1e3577b7c7817509115086de5f3b32d943b76ee3e5d3d555f88bc02b28e -dist/2026-09-29/rustfmt-nightly-aarch64-unknown-freebsd.tar.gz=44446b6fae2d871a1b6af2100f4c0783b3f000b348a1536c5c4f23b82c8107ec -dist/2026-09-29/rustfmt-nightly-aarch64-unknown-freebsd.tar.xz=7d37bb9b45eac9c1e2bbcc623da6dde1d653527d408292e913b4347f3622accb -dist/2026-09-29/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz=997a0e463191defc94ffa9405ba11a4a2bba1b220b40cef415a1a8d21e2e88f1 -dist/2026-09-29/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz=2050f09bd2dffd324c3b949626c35830d16f2e92a680a8c7001a19287d3d1b54 -dist/2026-09-29/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz=479090aac278503503b41acf936c774c645343a33193e5c149f9db28a301edc9 -dist/2026-09-29/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz=87b3f386c5372dca8676065403c0123935c7a47c5e69579beecc040a0b67ba15 -dist/2026-09-29/rustfmt-nightly-aarch64-unknown-linux-ohos.tar.gz=10da9a954bd0b76aab56c09ba01262eb87069ba18d67c36b982f3a5ca0ca3555 -dist/2026-09-29/rustfmt-nightly-aarch64-unknown-linux-ohos.tar.xz=f3db934402e31236c41188b5f85eab229e4cc8d108c9c33375e03bdd3b72bde3 -dist/2026-09-29/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz=9891c54c4cc027cb0e0edbf6c7b2d85a80287ff486074d8334cc0eea662fce48 -dist/2026-09-29/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz=8ef63b3fbace26c9ae4045bf08d8bc2c60fc6fcac095bab34f0743f82729a15b -dist/2026-09-29/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz=fabf81e854b1e1220756f2cc04cb911bff886af1a84f306bd38eaf3d7bf6e0bf -dist/2026-09-29/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz=f47aac3590c165cd800be1526278bc06538fddfbadc2f2ea0288a16274a3b04f -dist/2026-09-29/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz=fe5a0792b5f3f34e4854e257f3edf27e30c90938568e4ff576d374e5a4800cfd -dist/2026-09-29/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz=3ed3e957bbb5aeb4895cb5ddfcb93abd32a5c10982adb0724a3b91a578c9d5a5 -dist/2026-09-29/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz=d1e17fb001c32efa0455ce814ba35276e02de4fa41f858a1573f407ebfb79b21 -dist/2026-09-29/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz=d673931f677d95884fcbdb9dd1d971588ad8209b12b9ec10338f2c9e1516479e -dist/2026-09-29/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.gz=96cf73ca815b8b5c912cb82e2ee2d75d1d60a11bda9fe242173b8a74335441b1 -dist/2026-09-29/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.xz=a1af935bc9d319a962f388cb9d52981ccc1adae9e79ad561c520f92994b5b4de -dist/2026-09-29/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.gz=a614c7570d2f7370761938d62a93cf231d6673f4cf51be1ec13a86d7857d8a26 -dist/2026-09-29/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.xz=c7033f3846f19329e2d0c177cdc328387e9fd1d6738f44f3134fd73993e810e7 -dist/2026-09-29/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz=5a5c754617ff1d20b76c4f6a651bfbeb3446d133e2d7d1d151195d9c9709ba37 -dist/2026-09-29/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz=efba88f943670d427859c411c71090e3c9c503400c527432bf0f4e45aa9a640d -dist/2026-09-29/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz=bdfd3bd37453fd6c8cf965b2ccc56d0db4131dcb232843ff8ccb744126d07581 -dist/2026-09-29/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz=36fb9e8d537d9439391b2eac5357bc93d422be396fe226c4e7ada987ae1cd0fd -dist/2026-09-29/rustfmt-nightly-powerpc64-unknown-linux-musl.tar.gz=613aaa4c896802ad5065a846a0412e708ba4ec8d4cbb8c4cc268924edf50866d -dist/2026-09-29/rustfmt-nightly-powerpc64-unknown-linux-musl.tar.xz=d11268b84e0ad465d055208171268a63340724909916c9c4c8f2db7f77930406 -dist/2026-09-29/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz=3635e8a286ebf903e86b13e71a0c9da91b1cf08acd15fb529990e1bb01938994 -dist/2026-09-29/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz=7ba06366c9cb6641d177d1fea1efc74b4a70145f4947aea57dc3161d21e3b53b -dist/2026-09-29/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.gz=64fa9295cd882e817a913046856e11e3980740efedbc9dce3c9154e38c9a1088 -dist/2026-09-29/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.xz=190e0db21d5bfb1e47a6448566b42429a386e8ced68eccf29c575e8a17774aa2 -dist/2026-09-29/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz=780db7ef6ffc4d4e3bf37588d111b2733b2f30b22d1247111a7b6d290ed7882a -dist/2026-09-29/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz=0c55a5f391d9e032ec946bf2ea977b80514239c54109438e4ef17257bbae05e6 -dist/2026-09-29/rustfmt-nightly-riscv64gc-unknown-linux-musl.tar.gz=e9f3036825eae095bc415b485ad9397c96edc3481a258865db9d4b54e7cc9134 -dist/2026-09-29/rustfmt-nightly-riscv64gc-unknown-linux-musl.tar.xz=e4b3cac7c35db29013a22fa6e374011dea824909e3411ce4dabdb197344e0a9d -dist/2026-09-29/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz=c989d87883a750ae2e3d92366f22c0a55858dab9402260af5b2272b8b3eb10c2 -dist/2026-09-29/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz=e9cbc14a8c2a85229bd523a46982aaf50e242a810708f3ebb3eff2b89c8d1ddd -dist/2026-09-29/rustfmt-nightly-sparcv9-sun-solaris.tar.gz=9bcbe9b3c071008b490ecfc47e0b6007ef0577a488b71ffe829cac10c3f7b467 -dist/2026-09-29/rustfmt-nightly-sparcv9-sun-solaris.tar.xz=319876228cd9ba5319749c819fd127ff7fd9fb87e2886aa4eb97f14e13e95cf3 -dist/2026-09-29/rustfmt-nightly-x86_64-apple-darwin.tar.gz=a71ddea3e092dcd35a2b18c2538a7fc7df24b7fbde464e5b2a8014f86b24b843 -dist/2026-09-29/rustfmt-nightly-x86_64-apple-darwin.tar.xz=5b0ccd75907f3dc4a603cd60bbe87a11c3d75dc793adbdeb453fd385ef91df1f -dist/2026-09-29/rustfmt-nightly-x86_64-pc-solaris.tar.gz=26149456d7e5823901a3df9e5b4e49a93a04e02a536b324bfe2aa16dc5a5f4b6 -dist/2026-09-29/rustfmt-nightly-x86_64-pc-solaris.tar.xz=874f59be83371e0371bd30ccd4abcfe038377c2544ee2c3c577b8a8882a28ee5 -dist/2026-09-29/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz=bc002bd19c2d5c13692d8571c6a82cca5213dd5454e8f1d17215452683b612c3 -dist/2026-09-29/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz=09c04f5a4a7bf944b58b1b3a0a3142ac8450d7db5277028b881d7ab96242a0b9 -dist/2026-09-29/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.gz=4af726ea96c30759085ad6886d3d0b0c429abb6ca68990c382f2490ec44cb022 -dist/2026-09-29/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.xz=77e0d096d1d241c238dd84266a0d32500f3dc0acf142a644012a99eb50fb00f7 -dist/2026-09-29/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz=294cf327a6af4a8a88ddd6c3bd74a9877afe0940b6a451675f67b10c20588c1d -dist/2026-09-29/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz=8d2be13b650f7ce0eea90ad26f7b8f5b02771d140ef4b13d3b50ca0a7fe53e21 -dist/2026-09-29/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz=bb8a080ab727bf0503740763ce1eaadcedfd5f592b5462140d1038d397a973b7 -dist/2026-09-29/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz=35dc1d5b43934cb35f390491d62c5ebb570005f64edc0baab6456bf2421a71d2 -dist/2026-09-29/rustfmt-nightly-x86_64-unknown-illumos.tar.gz=7af5c6a369e6bee9a0239a5c2ebb901dbec8a5b4ed7dbefcd54b84d72cdcf2e1 -dist/2026-09-29/rustfmt-nightly-x86_64-unknown-illumos.tar.xz=633ea7cccf1ff5d0999efcb16a35da4e47911ec276b03bf62db5e87b38e82e88 -dist/2026-09-29/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz=cb4dc1c222f7cc67bb2a97418347fce26bdcec945567afc4867549901c9248ad -dist/2026-09-29/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz=243f7fd02c5e75bdbd2e35b0ff0ad916de1fe812bf05ae92e51e73f085ebf3bf -dist/2026-09-29/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz=864f2b4694d45c087f28a54096c5419970a8b7f21e8d60bcd34eef10c6505ab3 -dist/2026-09-29/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz=a461bbc1b5162ae9c7f0c6d96025b6eecf35f4f0bd472715a52937934049bd52 -dist/2026-09-29/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz=11653a0860011db783741465f11dd6833325d1396a82518acb4024d9f65cc545 -dist/2026-09-29/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz=ba8ac6446ce72fc0bad895759fe9fa281acabbf06ed676908b07a303849f1139 -dist/2026-09-29/rustc-nightly-aarch64-apple-darwin.tar.gz=f8bd07a928a00f5a58ecb90eaa3f5383deeca284ecd269c259dce96229c8dd9f -dist/2026-09-29/rustc-nightly-aarch64-apple-darwin.tar.xz=e76cb7ea5f41feb883ee7ed89bd71f48ec029eca9605d3aa757d952bd6a153be -dist/2026-09-29/rustc-nightly-aarch64-pc-windows-gnullvm.tar.gz=0c6136923cf94fa3910caa5440e2e68a4c517366154a57824a1e96f30da4fc81 -dist/2026-09-29/rustc-nightly-aarch64-pc-windows-gnullvm.tar.xz=bc94e0fe4523abe8ae134c068651b571e24ddb44a2ed7bbf40feff344d1668f0 -dist/2026-09-29/rustc-nightly-aarch64-pc-windows-msvc.tar.gz=1d0196716ec66f3a08092736407bcff0b5eeeb0ed9e700467f16959ca8167594 -dist/2026-09-29/rustc-nightly-aarch64-pc-windows-msvc.tar.xz=c08b4c0f3f5df85fb2a39a9e7748be6ce73bb4c17aa00549d3098a4e30738336 -dist/2026-09-29/rustc-nightly-aarch64-unknown-freebsd.tar.gz=3a513dd49f1fd8c80c8a9b51d68bf40a01a4fe6cf0c98a12420dc130e28c3a0d -dist/2026-09-29/rustc-nightly-aarch64-unknown-freebsd.tar.xz=3553abe463701c7b10bc853849e4273eb1f3a0d1d3c6e3d5dda106a41729e2ad -dist/2026-09-29/rustc-nightly-aarch64-unknown-linux-gnu.tar.gz=23732a3568613f3a0b2b06ab28e1732282297399ddfa07baccaa67c12f50ebdf -dist/2026-09-29/rustc-nightly-aarch64-unknown-linux-gnu.tar.xz=651734f660be3f83022f4a627c920753e19e79a7e6c0ee1e6c41f4f78c59767d -dist/2026-09-29/rustc-nightly-aarch64-unknown-linux-musl.tar.gz=fa01fe14d03160af899bf60866613826f83a180a6b9eafacb0cf97380059ebf8 -dist/2026-09-29/rustc-nightly-aarch64-unknown-linux-musl.tar.xz=3a67ebd7e6083ba65598070c2097e322eab032d4a5084bb6a829a51d4923e6b8 -dist/2026-09-29/rustc-nightly-aarch64-unknown-linux-ohos.tar.gz=444251d96d77b80d3b8252ab13108ef053c9482340fbed582b1bef245c258b32 -dist/2026-09-29/rustc-nightly-aarch64-unknown-linux-ohos.tar.xz=1df09853d89ca89950dcf058933dd4d760d1aad172a67b9f60c5b25522f0fe40 -dist/2026-09-29/rustc-nightly-arm-unknown-linux-gnueabi.tar.gz=61f9a4ade7f6daf6b5dfab631321b99625533bab506020594fbc9b6b7c1065c5 -dist/2026-09-29/rustc-nightly-arm-unknown-linux-gnueabi.tar.xz=21ccf42a6618c0b7c1db874566d1e1abe48556c6d8b45139f7c858583debdafa -dist/2026-09-29/rustc-nightly-arm-unknown-linux-gnueabihf.tar.gz=296d9251257c6b8a1225cc6cf5c422a790df5b9ccd2fb84d269bff701ee71928 -dist/2026-09-29/rustc-nightly-arm-unknown-linux-gnueabihf.tar.xz=d732c98eeefb447784ef6cb61c59fc919c3e48d4c291efff524cd9492a44e8ae -dist/2026-09-29/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.gz=5f50621c4463f2cd439922c2bb3b9d2e6af145bfe63aae0a2edec7073af7c758 -dist/2026-09-29/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.xz=52af25e8af238a3fe660f984c1c1cd28f90355cb78d5ba6a967bba94377572ef -dist/2026-09-29/rustc-nightly-i686-unknown-linux-gnu.tar.gz=55f65a08943922d590639588d8c29a6fba4049b33f20332195d72a71a7af7d2e -dist/2026-09-29/rustc-nightly-i686-unknown-linux-gnu.tar.xz=e234eb2638f14654677955ecdf87fe369d439da77cd466e0154f673898bee09b -dist/2026-09-29/rustc-nightly-loongarch64-unknown-linux-gnu.tar.gz=70772d9f7de70d4f0ac082e266bfe582a9c20969be33482f3f3244aeca11ee57 -dist/2026-09-29/rustc-nightly-loongarch64-unknown-linux-gnu.tar.xz=4f021e104f149d5c128b646bfd7a889c3bef37322ace9a5759075b42cde2c193 -dist/2026-09-29/rustc-nightly-loongarch64-unknown-linux-musl.tar.gz=b771b86f7af7055f876cd842f70288d26f34c9fb594b7930a43d94d22e07e6f5 -dist/2026-09-29/rustc-nightly-loongarch64-unknown-linux-musl.tar.xz=bfa7b382ac38053d6cd2a5fbda87494168ce54bfad95b161c0bc3790e94d99bf -dist/2026-09-29/rustc-nightly-powerpc-unknown-linux-gnu.tar.gz=576a6faa602ebc4eec32cc06209fe958f98ae584db2c8ba52c7d55bca258c16a -dist/2026-09-29/rustc-nightly-powerpc-unknown-linux-gnu.tar.xz=7a9563061646816f62ed10d8470ddc931d1df850342bca8a5e109dca445a487e -dist/2026-09-29/rustc-nightly-powerpc64-unknown-linux-gnu.tar.gz=d94deb2c8476421c2a223af821d7bda039ab853954e6e7eec3dc4235a4bd1de2 -dist/2026-09-29/rustc-nightly-powerpc64-unknown-linux-gnu.tar.xz=9d21d197013585e2cba456b76885c41e3b43a30c4004845fdc313eb33a38afcd -dist/2026-09-29/rustc-nightly-powerpc64-unknown-linux-musl.tar.gz=bab32e4293dd8052aa081aaa6643303d7b0aa4fbe3acbfd91c717a0bea776a5f -dist/2026-09-29/rustc-nightly-powerpc64-unknown-linux-musl.tar.xz=445b9ff411c8dc74cbc337b1b353c72dc75bc431eb997a36436e6b80987059ec -dist/2026-09-29/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.gz=c8ef38bc477c70fa0e7131c4971b52ae728524e80e29a2570dd5354d5dbe48f2 -dist/2026-09-29/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.xz=afb3c35107b8e4cb6edb48cfa71113084d6fa5360b28127a0e8e1948fa2abc7e -dist/2026-09-29/rustc-nightly-powerpc64le-unknown-linux-musl.tar.gz=9ce50d28b324c020b5fdb37db1a5522ed5a59815a14cfc117177a6c0d98a0d73 -dist/2026-09-29/rustc-nightly-powerpc64le-unknown-linux-musl.tar.xz=9bed9c6990d3ae6b33e60ffa7b60d0e9f6020b24c2c8b5cf7fff61474c87c987 -dist/2026-09-29/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.gz=5ae5f61985ed5dae8cd9f6d7638afe4957ef1d860a8e819249fdac1d58750e93 -dist/2026-09-29/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.xz=445bef041d5e64fdbd50ad4e883c6b831c4df8bc170f04f779fdccd5db553f02 -dist/2026-09-29/rustc-nightly-riscv64gc-unknown-linux-musl.tar.gz=57f862b615abeef4aa0988e9b023468230757454c30ff8af847a87f884e43f41 -dist/2026-09-29/rustc-nightly-riscv64gc-unknown-linux-musl.tar.xz=eaa6fd5bbb2a8e256e8f0a335f9b7ef33c60a40f0d4bae7a72ad1341809dc8aa -dist/2026-09-29/rustc-nightly-s390x-unknown-linux-gnu.tar.gz=1d2eb7ede0ef321f5a5eed1f19ff30c645048cad2dce1ee32a01fd473d07d529 -dist/2026-09-29/rustc-nightly-s390x-unknown-linux-gnu.tar.xz=892a029d3c60c9b037c073a02cad2c22247bfdf6c21ef94891eb5709ac85b3aa -dist/2026-09-29/rustc-nightly-sparcv9-sun-solaris.tar.gz=75ebd4fd6a89b3fa3529fecc6ab418a88aaea6f2085d2041bf7aa65cab57d1e7 -dist/2026-09-29/rustc-nightly-sparcv9-sun-solaris.tar.xz=56b8da62b8a49658c8a9a575bee49c28eaf955d21442e77c1740935f94d4b0bc -dist/2026-09-29/rustc-nightly-x86_64-apple-darwin.tar.gz=a1063ef2cf262f973c63358955bb1381fb37e73f154b44828b77091d3156a450 -dist/2026-09-29/rustc-nightly-x86_64-apple-darwin.tar.xz=99773bfc304755bc642fbc3617989bc62ee79f2265008c64d6ac15c514673f10 -dist/2026-09-29/rustc-nightly-x86_64-pc-solaris.tar.gz=b9c97ef49440e32d0f62012b1614b8e5cb9773efafeeec5517f82f6ef4f21623 -dist/2026-09-29/rustc-nightly-x86_64-pc-solaris.tar.xz=a286922465f006f15c802a8c1dce3c12ea73846a89006a917c86ebe20e605d7b -dist/2026-09-29/rustc-nightly-x86_64-pc-windows-gnu.tar.gz=ad9a406b01931b98be6021e991899cc1fb028a121b35ffd0a30d8b9359e3b940 -dist/2026-09-29/rustc-nightly-x86_64-pc-windows-gnu.tar.xz=8de44d3694475f3d7579f24d9d8c0dc66f927cd816db4cb572f81eb1e3eb5656 -dist/2026-09-29/rustc-nightly-x86_64-pc-windows-gnullvm.tar.gz=404c667f59d56ac591e9d043ec0427ac2a676fd2a1825442efc3465fe48719f6 -dist/2026-09-29/rustc-nightly-x86_64-pc-windows-gnullvm.tar.xz=f581783eb350436723bb5b4f12257dec703651b055998e3490f7af616e987479 -dist/2026-09-29/rustc-nightly-x86_64-pc-windows-msvc.tar.gz=530917988010ccbe9a6449f5136ba01958d5f94e282a41834b10e7017da11b20 -dist/2026-09-29/rustc-nightly-x86_64-pc-windows-msvc.tar.xz=8ad2b5afbc056d7515626ac2aef4b81d992469f70ebf41701222cca1bc2bcd3b -dist/2026-09-29/rustc-nightly-x86_64-unknown-freebsd.tar.gz=b693055d8cd4da607549da8ed0a186876a3db81f3a27deba1872439d68748014 -dist/2026-09-29/rustc-nightly-x86_64-unknown-freebsd.tar.xz=b55c0de331ce5601970e8227a34ada46ec394a18a86b89700b50d369b6dd59d7 -dist/2026-09-29/rustc-nightly-x86_64-unknown-illumos.tar.gz=54a37b89c59f32e12225f183cb4b0cf2c79721fe5dc15f5801c9527d426b2df7 -dist/2026-09-29/rustc-nightly-x86_64-unknown-illumos.tar.xz=0cff97495e37bdb45230d2ce7d57ccf06b767f6fbbb7cf69df57ae1595b8511e -dist/2026-09-29/rustc-nightly-x86_64-unknown-linux-gnu.tar.gz=ee5cf66faf459f360fb13c9898c2f588f5e04525ce29539c81147b3d0daaa3e8 -dist/2026-09-29/rustc-nightly-x86_64-unknown-linux-gnu.tar.xz=dba6569dd43bf3566bea07621fd270baac5ee75ca70a729c45bcef46f2725b9f -dist/2026-09-29/rustc-nightly-x86_64-unknown-linux-musl.tar.gz=ce2f90940e5911e475f10dc25f7f49a32a971b375bc5d990de4c729f3efde5e0 -dist/2026-09-29/rustc-nightly-x86_64-unknown-linux-musl.tar.xz=7a3b06231fb1604c465c241951cb6c2286d841bb175da13d933c24bc5822a2f5 -dist/2026-09-29/rustc-nightly-x86_64-unknown-netbsd.tar.gz=ce146f46f22b2cb210fbd5a2ce33511b309101f2e1e290db4319e8ed14894bf9 -dist/2026-09-29/rustc-nightly-x86_64-unknown-netbsd.tar.xz=9c787a33d96d02b05e1ad8eb0ce6da8de1f531a05e05199ac4ed8dff051314cb -dist/2026-09-29/rust-nightly-aarch64-pc-windows-gnullvm.msi=a4c6d25c32b5a0a751b53568185e1bb29b6701e9c78a3c964c99de435d5df5d2 -dist/2026-09-29/rust-nightly-aarch64-pc-windows-msvc.msi=1bcc25f2c3c3d154578d314d51488de9a5db11759a38703a6ecf8bb5a5d6d6a3 -dist/2026-09-29/rust-nightly-x86_64-pc-windows-gnu.msi=3f8abd777867a484177ebce45009325559fd89f56065c257cc12e05b679b1658 -dist/2026-09-29/rust-nightly-x86_64-pc-windows-gnullvm.msi=be77343c9728e594b2f355f0d1c03a42ecde8757b2ff4ce4cd6da95a4dbd3e34 -dist/2026-09-29/rust-nightly-x86_64-pc-windows-msvc.msi=a080cc47533ac72c19cbd2b309fab14f33ae11f7aca18feb7a1c955883df37e6 -dist/2026-09-29/rust-nightly-aarch64-apple-darwin.pkg=1485843b8c0f53e3b50dd277aef08d2669a01ce6485bacf202c8f24fbebaf623 -dist/2026-09-29/rust-nightly-x86_64-apple-darwin.pkg=62ef2681dc83414c208c981949efbfc007b9b9ac8ab1bee776b3ed42130f2fe5 -dist/2026-09-29/rustc-nightly-src.tar.gz=54f78062b491bb27ba1eeedcf59fe8f0ce7c4e30189613af34b711feb4839ff8 -dist/2026-09-29/rustc-nightly-src.tar.xz=5d38310ee84c42e638094781bf1ec5456977fdc64021a83c8e0779d04371159a +dist/2026-11-10/rustc-beta-aarch64-apple-darwin.tar.gz=d5f515d215f42c3a5249de8e2d2a1cdc037f4fc4264e55482857df9fb932280e +dist/2026-11-10/rustc-beta-aarch64-apple-darwin.tar.xz=38a49aada4a40983ba9b96a942d4dcba071a15bd3fd89d92d6a1552708a0649b +dist/2026-11-10/rustc-beta-aarch64-pc-windows-gnullvm.tar.gz=0d1a6ae2bdc3a1d0d061ff1963ba0625058191cff479e25954890405ea1eb1a6 +dist/2026-11-10/rustc-beta-aarch64-pc-windows-gnullvm.tar.xz=79297309ecb7ce066daed9d2b67f718404d20df1b56109539d23faede2fafbcd +dist/2026-11-10/rustc-beta-aarch64-pc-windows-msvc.tar.gz=5698dbd1d5cc69c9ab8944b83a36d0113dd33dd4f2b2fa0033e981920d168f30 +dist/2026-11-10/rustc-beta-aarch64-pc-windows-msvc.tar.xz=ec5f4c80b758dddc8c4f932453391fd38b1287a7de0643f8311929479b70d31c +dist/2026-11-10/rustc-beta-aarch64-unknown-freebsd.tar.gz=d7e06ae8788f147ebb7e64692fd52342f6701aabbe13af828ef9f1e9b1a81963 +dist/2026-11-10/rustc-beta-aarch64-unknown-freebsd.tar.xz=2d5aa4abd78846b1e93274ff14c46561f2a24429ed7ddf51329d56a88b9e720c +dist/2026-11-10/rustc-beta-aarch64-unknown-linux-gnu.tar.gz=bb1dce857d7547374a4f2ed1b43aa54a06831149a87900a34b82f25ef7abbdfd +dist/2026-11-10/rustc-beta-aarch64-unknown-linux-gnu.tar.xz=fed71acda1c2e8f7d0e3c4bc6fa948a74adb3d8c9979ef148b9831406ccd5c7f +dist/2026-11-10/rustc-beta-aarch64-unknown-linux-musl.tar.gz=c2763273dd1e2498b560bc6f03a9cb0cbd1452c8eae4dcdbafc83fc458da4716 +dist/2026-11-10/rustc-beta-aarch64-unknown-linux-musl.tar.xz=8134658409fa3662aeb602a16952347a5ba5ef5414bfab420b4dd40b136b55c6 +dist/2026-11-10/rustc-beta-aarch64-unknown-linux-ohos.tar.gz=2793bcb24132a8d412d9855894e40232c777af68c65b369d861672eeb2b55ab1 +dist/2026-11-10/rustc-beta-aarch64-unknown-linux-ohos.tar.xz=536524e46dbf1221f734ada0aa31eeb083f3456601cf1ca9ee4d95db75284a3c +dist/2026-11-10/rustc-beta-arm-unknown-linux-gnueabi.tar.gz=7587bcd92a17e3045635b502606dfc70a49a6180400c334fb44d99363a46989c +dist/2026-11-10/rustc-beta-arm-unknown-linux-gnueabi.tar.xz=fce259b40eccdd44edd271bdf8157ff3b8bb7a66e0c0fe949e39e61913932b26 +dist/2026-11-10/rustc-beta-arm-unknown-linux-gnueabihf.tar.gz=0ba8c1df8ca910631fbd3c60694eea27edeae3c7ee9420d26b70c25a0043b2e8 +dist/2026-11-10/rustc-beta-arm-unknown-linux-gnueabihf.tar.xz=9453ce4868f625acb233d454821812ab53a113c4f3938316c07812c6d83e91f5 +dist/2026-11-10/rustc-beta-armv7-unknown-linux-gnueabihf.tar.gz=05a290b945e75a68bcca1a96d4727ed47e7c42dbc3e60a876aca0e4919c6c464 +dist/2026-11-10/rustc-beta-armv7-unknown-linux-gnueabihf.tar.xz=f9dce723d9862bc578830ce089af62c862ec91c8b3af8573d075f7213bf492a2 +dist/2026-11-10/rustc-beta-i686-unknown-linux-gnu.tar.gz=7faf8d19b3a8027b403837401295ec702af507f90168c8fa1a0148de61e11b48 +dist/2026-11-10/rustc-beta-i686-unknown-linux-gnu.tar.xz=7778c705bfdd69e309dd1af9724cc0b36f201917f77cc6b404ddec840e6c354d +dist/2026-11-10/rustc-beta-loongarch64-unknown-linux-gnu.tar.gz=18408b77598256f5fd56c094b587b63a88a73183a8e928c17f55e18c55f051de +dist/2026-11-10/rustc-beta-loongarch64-unknown-linux-gnu.tar.xz=4418670353a772d9b03b80b79500c0170798844b9802bf4cf6779ac5d06513f8 +dist/2026-11-10/rustc-beta-loongarch64-unknown-linux-musl.tar.gz=c16e8ba265ede895a39efedf367a0ffd3e6a049226e0323aa88ecff71bf24885 +dist/2026-11-10/rustc-beta-loongarch64-unknown-linux-musl.tar.xz=cd3418f80ee0cfd369390afde54b9b057d61152ccc6ae37e37c82e8cac1f7a81 +dist/2026-11-10/rustc-beta-powerpc-unknown-linux-gnu.tar.gz=569bedd835f56d6058146b91efce2759313c913fdd7221aeb61744a67c3c91e4 +dist/2026-11-10/rustc-beta-powerpc-unknown-linux-gnu.tar.xz=f050568253ce7501a0fe01be33e20b7e62d8c98d7589b8f1466b888686efe65b +dist/2026-11-10/rustc-beta-powerpc64-unknown-linux-gnu.tar.gz=dca7aeb2a4592f20c9201342b15dbd1d1da8cbd75fac36fa5da12b56c034dd7f +dist/2026-11-10/rustc-beta-powerpc64-unknown-linux-gnu.tar.xz=006e16cff01bba8bde3295a08bb46030b4b17b937fa849f37d52987f5ee64381 +dist/2026-11-10/rustc-beta-powerpc64-unknown-linux-musl.tar.gz=e9724f1b014dba22501d9e83a4608c7a5aea3677b0473e667a49afd032b7e25a +dist/2026-11-10/rustc-beta-powerpc64-unknown-linux-musl.tar.xz=d15adc36523132b9cdceb06ae68725aebf136ef96a00ac9379e311b59b6c6efb +dist/2026-11-10/rustc-beta-powerpc64le-unknown-linux-gnu.tar.gz=b7bcde77a93478fc6f4a4d33371ea306ea0dbc9844943485ca45e47a73124e4a +dist/2026-11-10/rustc-beta-powerpc64le-unknown-linux-gnu.tar.xz=9f646e7f31cf252ecdfcc77af40436c7f20cb214e6e0254c05ee34bb4fbf07ad +dist/2026-11-10/rustc-beta-powerpc64le-unknown-linux-musl.tar.gz=9345a7a899a18446d53dddfd23061f95c5e0849237092f51bc80142a186258d7 +dist/2026-11-10/rustc-beta-powerpc64le-unknown-linux-musl.tar.xz=acc168aee2d022fe342eac1d622f05e255e6b927f60a448cc1d57cd0f6baaaed +dist/2026-11-10/rustc-beta-riscv64gc-unknown-linux-gnu.tar.gz=7acc1d3fc0f1db8382681caa664e71496f07c2cc0dee3ec48b3b37919161e81c +dist/2026-11-10/rustc-beta-riscv64gc-unknown-linux-gnu.tar.xz=88d2fcb76f0adc794ab7f5007974d73d69c1630d73a8f2175ffc6d4c7d007682 +dist/2026-11-10/rustc-beta-riscv64gc-unknown-linux-musl.tar.gz=ca9011fffc09532c47951e314b08dce4ce135a388db86d7e47e84587b0916bb1 +dist/2026-11-10/rustc-beta-riscv64gc-unknown-linux-musl.tar.xz=f74a6534ab4e2a4a3e2f352a59c595a81257b819196ff7bc0c76c6d692e95b63 +dist/2026-11-10/rustc-beta-s390x-unknown-linux-gnu.tar.gz=288b33a490cbca7ae683a130d4ab8ee192794f03e487a5cb9367ba2a8c337691 +dist/2026-11-10/rustc-beta-s390x-unknown-linux-gnu.tar.xz=cdd551eb05d442c82ca02d18add92aba630da9defda7eb14e4f25efe7b8deb46 +dist/2026-11-10/rustc-beta-sparcv9-sun-solaris.tar.gz=ea1d437f9862ad29faec1c7326adba07a9591859cfcfd04d035ca7dbfaef4eb3 +dist/2026-11-10/rustc-beta-sparcv9-sun-solaris.tar.xz=f929d0cd9eae4a9dd51348d565e35db1f0c7910ced771514c701ce2082db9f21 +dist/2026-11-10/rustc-beta-x86_64-apple-darwin.tar.gz=17b6d10f5ee672e1cdc4e4eee435459bfca37976f6f50ba5210cb353bc93d6b2 +dist/2026-11-10/rustc-beta-x86_64-apple-darwin.tar.xz=b696c44629b8e9db4cf9446f4c697ea1af76c8035ac981332d948e241820bf7f +dist/2026-11-10/rustc-beta-x86_64-pc-solaris.tar.gz=0228ff5d130507a8f8d42019893af0a9bcfcb87b0a0a7df6aad798d36b1e2635 +dist/2026-11-10/rustc-beta-x86_64-pc-solaris.tar.xz=d5a4efefd7af2671cfc69251c4a95a2d88b0348c3cdd5fa59c049b8bc02cf740 +dist/2026-11-10/rustc-beta-x86_64-pc-windows-gnu.tar.gz=a30c8a82e6baf49ea64e8f7a4fe433dffd2b2a7851b45bd2f9d43d01dfd98bdd +dist/2026-11-10/rustc-beta-x86_64-pc-windows-gnu.tar.xz=4ad1236a0ba815aa41bd35231f8d86cc8fe80c4261fef89bad5d4e0f273607a3 +dist/2026-11-10/rustc-beta-x86_64-pc-windows-gnullvm.tar.gz=25631ba3783f98ecc779cba82c5b3317463acb7466f08aaa4775f04f8ac078a1 +dist/2026-11-10/rustc-beta-x86_64-pc-windows-gnullvm.tar.xz=13a7f5b60f69c3bf5a24ce7a79618f968e11b930622c2c3bc7f52dbfd09fd2f9 +dist/2026-11-10/rustc-beta-x86_64-pc-windows-msvc.tar.gz=501359979948866c03debd4c710e1c4252dc5a3b7b521f441f20acf5a7cf0bce +dist/2026-11-10/rustc-beta-x86_64-pc-windows-msvc.tar.xz=12b0857e6f57c508707e4057dce80421f77d1a59647bd736992da4eb353a70ce +dist/2026-11-10/rustc-beta-x86_64-unknown-freebsd.tar.gz=df69b8902e7a55e9d088f29eac7b13a65f84858a670cc7e56b317040c82b33e1 +dist/2026-11-10/rustc-beta-x86_64-unknown-freebsd.tar.xz=c9a97d5e280223b36befb175a3b0cf769c98dcd02e75d983e504e4ab4120907d +dist/2026-11-10/rustc-beta-x86_64-unknown-illumos.tar.gz=0d96ae13883cf7f733a809ce3c9d819aeda4258fe80da6ac7a1b6095730c9cf4 +dist/2026-11-10/rustc-beta-x86_64-unknown-illumos.tar.xz=e1762e931e9383be3a0a4c0a8b168318f44d5a363f261dd7a8466690e20c3fec +dist/2026-11-10/rustc-beta-x86_64-unknown-linux-gnu.tar.gz=c1f1ecbe9db66295ad1fece1bd7f6b842139bf438fb63aa23b4739fe4146c46b +dist/2026-11-10/rustc-beta-x86_64-unknown-linux-gnu.tar.xz=7d260cea2bebd0bd04dfe847c146f26afdaf6eee06659d39d3d223372486fd98 +dist/2026-11-10/rustc-beta-x86_64-unknown-linux-musl.tar.gz=0542b683e13cbf4c52876989e52f0cb1d371e3a7dc24d98a9c91cc9e475b2ed3 +dist/2026-11-10/rustc-beta-x86_64-unknown-linux-musl.tar.xz=92255cc0c3f74ade0c8d6b67734dd13fda297580610f9668104a254b86f817d1 +dist/2026-11-10/rustc-beta-x86_64-unknown-netbsd.tar.gz=4b08a11d35f0ac8f483959db09a60ffd7dc9a799ce5cec9ccd8dcc8fe9c4b86f +dist/2026-11-10/rustc-beta-x86_64-unknown-netbsd.tar.xz=11000577b2a81fdae726bccc648092b7e87ce014be6fb91b911c40a48065e8b0 +dist/2026-11-10/rust-std-beta-aarch64-apple-darwin.tar.gz=ac19b4db21516b58a612981a94e85b235cf52fb068f59ddc7abf3dd0ada3b9fa +dist/2026-11-10/rust-std-beta-aarch64-apple-darwin.tar.xz=3920898cd075031dfde7b0ca279c97a455ec1857b547f75e9b7806604b052809 +dist/2026-11-10/rust-std-beta-aarch64-apple-ios.tar.gz=736a445d659b7fde0a69d82965872b58607a7e85d1cfa9672a8ecf29947b8b15 +dist/2026-11-10/rust-std-beta-aarch64-apple-ios.tar.xz=7ff91f4835c41115aae5c3195c3c571e2e7966c3a5b06384671e761bd1873e2e +dist/2026-11-10/rust-std-beta-aarch64-apple-ios-macabi.tar.gz=b9733acd0baa7d3e7f82872d510c335d375c61b619e0fcceaf3ed8ed01c5813a +dist/2026-11-10/rust-std-beta-aarch64-apple-ios-macabi.tar.xz=10b90c1b65dfd18f628006caf351c23deb60451487f512b45fbc572d0c79ffa1 +dist/2026-11-10/rust-std-beta-aarch64-apple-ios-sim.tar.gz=5d146db30c4f49bb1d17d5d75d824a6ce91c6b8412fbcfe6b3a9a1472470326b +dist/2026-11-10/rust-std-beta-aarch64-apple-ios-sim.tar.xz=2f8c72b654066bfcc761ffc52a66b8baf2f80dbaab0c75454cd80a58089f4131 +dist/2026-11-10/rust-std-beta-aarch64-apple-tvos.tar.gz=146569c573d969c2aa09bbe531d015304f5247aa11a10472f1e878dd9779eccc +dist/2026-11-10/rust-std-beta-aarch64-apple-tvos.tar.xz=a83f8e367ad1a08daf4200a9d8851a350a48d6e03fcea02e98a20a9fe9bacddf +dist/2026-11-10/rust-std-beta-aarch64-apple-tvos-sim.tar.gz=a59f44e38d49b942030a2e2df0f3eba369cadd87f2a42d9137db874b62c2640a +dist/2026-11-10/rust-std-beta-aarch64-apple-tvos-sim.tar.xz=8e5db90b72710b1bc47b2fd5f55f7e69176837dcc8dec2a81708c6c5d20758c2 +dist/2026-11-10/rust-std-beta-aarch64-apple-visionos.tar.gz=bb89cc2b5b5e21c529759c1fb9d9bb6d4d3f68b6679a6cecc5c800981e6a4405 +dist/2026-11-10/rust-std-beta-aarch64-apple-visionos.tar.xz=5bf745184607723cb80d92babab4da21f91109e6be2194af95d9d1f579dd8178 +dist/2026-11-10/rust-std-beta-aarch64-apple-visionos-sim.tar.gz=45b9edaa4360d463f60fe11fdc9b1ebb00697e28359899ff13c00de8532743da +dist/2026-11-10/rust-std-beta-aarch64-apple-visionos-sim.tar.xz=537236e6fdbe8ae67b9d35f687f9152f2ace6481d663d049c2faa185acfad384 +dist/2026-11-10/rust-std-beta-aarch64-apple-watchos.tar.gz=778e48c06aa438ab696a7cf8427ec1f4c457a00484652a295754468edff848bc +dist/2026-11-10/rust-std-beta-aarch64-apple-watchos.tar.xz=6ddd6e7e48a4ebec02d43ce663a9a31f2bb3af9aaaaf1bb622f1b6d39a3f6467 +dist/2026-11-10/rust-std-beta-aarch64-apple-watchos-sim.tar.gz=a110fbc99e75e07a8fc7f5758805173e7a232cbffe4ecf6391a5fbdfeb0d6d11 +dist/2026-11-10/rust-std-beta-aarch64-apple-watchos-sim.tar.xz=a8e941093f6614c147d8809cb608ee631839e503c2ef6f21eb0b8c8164cba270 +dist/2026-11-10/rust-std-beta-aarch64-linux-android.tar.gz=1e6c099d4381d56c7f4af54fe962fe68cb4d2a76f6ddffa9068cda8f857cb92e +dist/2026-11-10/rust-std-beta-aarch64-linux-android.tar.xz=ec55b76b123faa1af1de275957210b77c42524d90b847098ae90dcc1c02ca465 +dist/2026-11-10/rust-std-beta-aarch64-pc-windows-gnullvm.tar.gz=58e223f4feceea6f64ef67b12d63c745782084a97925c228760ebcb8cc494c9a +dist/2026-11-10/rust-std-beta-aarch64-pc-windows-gnullvm.tar.xz=c0f117d074dec45ad8dedc77eb01d127fad94925bb733736cb8bd1922eb9dd8a +dist/2026-11-10/rust-std-beta-aarch64-pc-windows-msvc.tar.gz=5557cb5dc294cede8a3acf9822e2535438a80161956b76eedf163c7eb5f70499 +dist/2026-11-10/rust-std-beta-aarch64-pc-windows-msvc.tar.xz=977b2317e8983acfb2156028c4b0c010218c6773caaac00b9f0a346017815805 +dist/2026-11-10/rust-std-beta-aarch64-unknown-freebsd.tar.gz=c34ac7c5afb41b90fb2dd6ef3570db2455da538ec5e73232d2d11693a3b1232b +dist/2026-11-10/rust-std-beta-aarch64-unknown-freebsd.tar.xz=7d13c21e4fbbc59f3d3c91d3f57d744a64288ddb49f9071f8c88057702ef6e2e +dist/2026-11-10/rust-std-beta-aarch64-unknown-fuchsia.tar.gz=bc06342484a0fa91a80bdc120fa53cfa6030a77d725930c997b574828e05144d +dist/2026-11-10/rust-std-beta-aarch64-unknown-fuchsia.tar.xz=25a7adb1a48b0a3d20b93bc2c408fadb68e6ac3a74cfd6580ad9b73ca497e69a +dist/2026-11-10/rust-std-beta-aarch64-unknown-linux-gnu.tar.gz=6fa13038b32c75fe622877c68bbebe96158d9c0146e14648a985302cf0c46161 +dist/2026-11-10/rust-std-beta-aarch64-unknown-linux-gnu.tar.xz=420d6eb27ed65fab4f27c89d32b438dd366064538a7e93f720658a40ae0d7d08 +dist/2026-11-10/rust-std-beta-aarch64-unknown-linux-musl.tar.gz=dcf8c0181254fa3707c1014e79718cdf9730b967ddb1b96e253afa22800e4c3d +dist/2026-11-10/rust-std-beta-aarch64-unknown-linux-musl.tar.xz=e1d15e1f1f3b7919eec046370f05241e4e68c2d5f9088d20c53d1650c3bce1e5 +dist/2026-11-10/rust-std-beta-aarch64-unknown-linux-ohos.tar.gz=accc96c8330f3b0e0ebab0fdde0d4ce2085a880323c0f089d8226d06212cda8e +dist/2026-11-10/rust-std-beta-aarch64-unknown-linux-ohos.tar.xz=3f4a1f7f82e71fb7887d7590092a61521108def6466f3a772de6c6f8afb8bed9 +dist/2026-11-10/rust-std-beta-aarch64-unknown-none.tar.gz=83ae181a639e96dcc39dfdf969201ecd5c249fd8c890a5f617702685913502a3 +dist/2026-11-10/rust-std-beta-aarch64-unknown-none.tar.xz=ea463ba2c84c8ce8224014f3281eef55ee6868a364091f80c79c06b9fdf2cc11 +dist/2026-11-10/rust-std-beta-aarch64-unknown-none-softfloat.tar.gz=519b8967bbbb7ceba2114c023a03a0dfc053e3832f84a1cfa42e48721bf4e356 +dist/2026-11-10/rust-std-beta-aarch64-unknown-none-softfloat.tar.xz=6af79845377213aa8bf98929f178957a7c991dc13bc6ef2c7285d483516741e4 +dist/2026-11-10/rust-std-beta-aarch64-unknown-uefi.tar.gz=02fc451a63e357792722c5dcef24dd88c853848ad3b20f4a652254d2f804e761 +dist/2026-11-10/rust-std-beta-aarch64-unknown-uefi.tar.xz=f116a0b6726f4ed476c568b7796c17d50067a734415281f133cb9162b0e45811 +dist/2026-11-10/rust-std-beta-arm-linux-androideabi.tar.gz=4492629679562f018bfe6b6ed651e5592edf3ce455cf1458fc412f9309d5635f +dist/2026-11-10/rust-std-beta-arm-linux-androideabi.tar.xz=02dfc8bd3dd100012a6284be2bacc37c58533578f9893d30ba4d4cb90451168d +dist/2026-11-10/rust-std-beta-arm-unknown-linux-gnueabi.tar.gz=36274fe0043491eda38b0e02639519b6680ba54a3fb5e913bdee382c043deceb +dist/2026-11-10/rust-std-beta-arm-unknown-linux-gnueabi.tar.xz=62ddfefad2f3e50b1bbbd36b4d2de07f352b3369e3500e6f526e3d812d734a29 +dist/2026-11-10/rust-std-beta-arm-unknown-linux-gnueabihf.tar.gz=493f9627debdb93a30609c531ac7ee4f82e7be44182b0c86eeb4273ad3071143 +dist/2026-11-10/rust-std-beta-arm-unknown-linux-gnueabihf.tar.xz=b6d3721323f6331c67bd07f49b3a174c290dcace3840dea00dcfe9fca0142560 +dist/2026-11-10/rust-std-beta-arm-unknown-linux-musleabi.tar.gz=28efd845a4f32ba5a459cb495b25f8ec15a0bcac92ca700b8df7db00a5d1c899 +dist/2026-11-10/rust-std-beta-arm-unknown-linux-musleabi.tar.xz=6180c7e2597c1f8fb0b09825a875294eeccf21c4a0408983ff7aee3eb38b4f2e +dist/2026-11-10/rust-std-beta-arm-unknown-linux-musleabihf.tar.gz=a820d4b1428a833405683fafe2da3a694f86ff948482c67c8a80d81ac4e4b14d +dist/2026-11-10/rust-std-beta-arm-unknown-linux-musleabihf.tar.xz=a617ba1b29b9de798989630b4e5bbfc7e48163c344a91e4e7aebdbf98c69ee88 +dist/2026-11-10/rust-std-beta-arm64ec-pc-windows-msvc.tar.gz=d3ff1741fe5f116d10d6333155d0973ba41d7ee802cc788183581dd179c6d539 +dist/2026-11-10/rust-std-beta-arm64ec-pc-windows-msvc.tar.xz=37c134ccd3c067dab23b2c9193b4af5a02a7db4c435020ae886d8690d6e2460f +dist/2026-11-10/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.gz=d85fa8f8fa8dcea06174b704de1b8b8d6f73c0b73c613596254d2319fe3ecf18 +dist/2026-11-10/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.xz=890c5f800975c0d547f1cdccd6cdb4419005c06555a2301cc18972c3a9b926e2 +dist/2026-11-10/rust-std-beta-armv5te-unknown-linux-musleabi.tar.gz=4b69ebdfe40e66cd6eb72d32e5770bd3e08a91752f35265dc73b7b14d68ecf62 +dist/2026-11-10/rust-std-beta-armv5te-unknown-linux-musleabi.tar.xz=b12d6d373b9ffe156c59dd6997c22f5be91f3728becdc14d324cd77451bcae22 +dist/2026-11-10/rust-std-beta-armv7-linux-androideabi.tar.gz=90880280fb405bd1fc9855231753fb53a842467c6865df29553b692cc5ab09b1 +dist/2026-11-10/rust-std-beta-armv7-linux-androideabi.tar.xz=90f176c7eb2b1639e6a771d705da59baf76ecec915b72b8054d00f1539b8470a +dist/2026-11-10/rust-std-beta-armv7-unknown-linux-gnueabi.tar.gz=65c87ea897d32a4090cba95296c3695eef2b565753d67aee56da9e3397c13fe8 +dist/2026-11-10/rust-std-beta-armv7-unknown-linux-gnueabi.tar.xz=46e78e192f98d6cbd6a50374153ca8769007433519994a1332086f41632a43ff +dist/2026-11-10/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.gz=78457403c019471a753f28b0086826f44a54967a8eb439827eb74c770be08f99 +dist/2026-11-10/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.xz=c0d0af888664901604297820078e25f4e85ad8a31727105ee1578f34b1c1898f +dist/2026-11-10/rust-std-beta-armv7-unknown-linux-musleabi.tar.gz=289e23120e0e1aeecd2ee74ab3f482b28cc55f4d6b500c0cc8f0021c8572281f +dist/2026-11-10/rust-std-beta-armv7-unknown-linux-musleabi.tar.xz=d8a347ef6fc457c117f9eeaa9cb517d484020cfd0e15b692aa2cfcd49e3f80b4 +dist/2026-11-10/rust-std-beta-armv7-unknown-linux-musleabihf.tar.gz=84e41bc2b7c17bf7d5762d67cfa09e428ecfd97bff5f5fde6b63ce48d8c4d012 +dist/2026-11-10/rust-std-beta-armv7-unknown-linux-musleabihf.tar.xz=a6947c592cb7bb26f7fe288ffe8b814225515a9574163fc0a3381f021b6ee7ad +dist/2026-11-10/rust-std-beta-armv7-unknown-linux-ohos.tar.gz=2b1640d3119ba5107550d9e2a07ab70c0b8d830884bf964852ff1da9ec148e75 +dist/2026-11-10/rust-std-beta-armv7-unknown-linux-ohos.tar.xz=4e5aa07e4be23239213463a074cbd10532d98f1eb627a9b01766f9bc1ae3894b +dist/2026-11-10/rust-std-beta-armv7a-none-eabi.tar.gz=4aea296abe0453f0d0d131124dedbb389c19aa6ad9d2e0f7edfee0313d49b083 +dist/2026-11-10/rust-std-beta-armv7a-none-eabi.tar.xz=d2bee086b35a87186b850246a5f094775dcf0e9f6fe48ccdf5ae19fc94fe3a36 +dist/2026-11-10/rust-std-beta-armv7a-none-eabihf.tar.gz=da19943af89cfd3daa0d3caeceb0efc486136478f2f3461d38953c16622e44c3 +dist/2026-11-10/rust-std-beta-armv7a-none-eabihf.tar.xz=69a36b9c35929b64b0598f774cb0311143d32cea06d80aa25727bf8c3aa6cd71 +dist/2026-11-10/rust-std-beta-armv7r-none-eabi.tar.gz=6ed007eb3b85dfba30644d13c6de7a3262eb3459356bd25f3015b34321b632af +dist/2026-11-10/rust-std-beta-armv7r-none-eabi.tar.xz=f754075414ce264564075eef066c5b06759b0084f2d7ad3c1c7d967a6ae65abd +dist/2026-11-10/rust-std-beta-armv7r-none-eabihf.tar.gz=d9c1db7ca119c2826012e25f24573323d8eeba7364b5365c2e96f42d73f63adb +dist/2026-11-10/rust-std-beta-armv7r-none-eabihf.tar.xz=35ee8a4dfeeea90082315a55d5cb0fc99c9136fd9785842a32fef3feb0dbb77b +dist/2026-11-10/rust-std-beta-armv8r-none-eabihf.tar.gz=bac80bc5bb453e9a9f48fda282449d6823543419bcbcaf14a47a5a0549b2134d +dist/2026-11-10/rust-std-beta-armv8r-none-eabihf.tar.xz=5ef325aadbc509a0ea8f511d6ac1bdeab03b15b54ebadccc4d848115bbee680f +dist/2026-11-10/rust-std-beta-i586-unknown-linux-gnu.tar.gz=44eaf9b961568d31fedcffcba273c04c582070d7d89cd331b7e0dfb32b7d587d +dist/2026-11-10/rust-std-beta-i586-unknown-linux-gnu.tar.xz=a270e747d1c49de681b4a928020d9db803136210ac549439a721b4e71cf43f1c +dist/2026-11-10/rust-std-beta-i586-unknown-linux-musl.tar.gz=e80dee7ed46c207dab1788e550b3ab037b3826ee50d1041fea6321a8a60e8647 +dist/2026-11-10/rust-std-beta-i586-unknown-linux-musl.tar.xz=252039bea12d17ff3b36a2593548c7ff30d0554dfa4e020c0b0fdda100e61211 +dist/2026-11-10/rust-std-beta-i686-linux-android.tar.gz=b2102bea57d531a457cb572a39c09b24aa12cd41128d27abaa4016414bd9e327 +dist/2026-11-10/rust-std-beta-i686-linux-android.tar.xz=3b258b6e4e3a293f10043bd6f85cf08dbd00a01af1e8e4fd4a4687cfb296dfd8 +dist/2026-11-10/rust-std-beta-i686-pc-windows-gnu.tar.gz=2f7c26c1a1e76d589f85d78990d6fbf8d71660451a504266c99e014be60f4749 +dist/2026-11-10/rust-std-beta-i686-pc-windows-gnu.tar.xz=e4559b67349beb8361237d1621055800bd4177dbb9ced6d26af1efdba6f2d613 +dist/2026-11-10/rust-std-beta-i686-pc-windows-gnullvm.tar.gz=85b3e47498242b93adb50d8a1b1d4c5213e0768d10bd1aa896b0413d461f407e +dist/2026-11-10/rust-std-beta-i686-pc-windows-gnullvm.tar.xz=9f36c6fae85db0ceedfe989d955d7cd733950b10a6e4a69e8ddbcab1f64edf0c +dist/2026-11-10/rust-std-beta-i686-pc-windows-msvc.tar.gz=db514bcb34f2c898a09ee332f75f44b55b61d1a50205b78b413357eae9bfd9c8 +dist/2026-11-10/rust-std-beta-i686-pc-windows-msvc.tar.xz=5a94ae7cd270a989e61855e55c8c95ea121c3efcfb39d376c39e34932be302d5 +dist/2026-11-10/rust-std-beta-i686-unknown-freebsd.tar.gz=900445f0d7270d0565682d2379b52666dcaf5430d207d501d90d1697515037b9 +dist/2026-11-10/rust-std-beta-i686-unknown-freebsd.tar.xz=131c1c51ece48219cd2a8ea38c4aff99bb673d15b3d532917c2de1e3bb357945 +dist/2026-11-10/rust-std-beta-i686-unknown-linux-gnu.tar.gz=a96dfde97762a519fc6721dcfab41ae103b8044d3524128c59c83f82e5f738c4 +dist/2026-11-10/rust-std-beta-i686-unknown-linux-gnu.tar.xz=a3c265920328757be251384b38d70694103547b27f71af1c611abdf4a7c3c725 +dist/2026-11-10/rust-std-beta-i686-unknown-linux-musl.tar.gz=94a399bfb9be7f309dc761403b85c697320b3de2dfc3294bd178941e402d769b +dist/2026-11-10/rust-std-beta-i686-unknown-linux-musl.tar.xz=bc322ab3da4b30842e404e156905333773e6552bb2181b7cdcc8eaae99088eba +dist/2026-11-10/rust-std-beta-i686-unknown-uefi.tar.gz=d7e3a918040a1705367758d00d36c498191bd803e2423b3df4c1fd1b961f2cbd +dist/2026-11-10/rust-std-beta-i686-unknown-uefi.tar.xz=a21c08459287233e0d73b377180e75cd510675c28f1f3a9293948d9133d4c7d9 +dist/2026-11-10/rust-std-beta-loongarch32-unknown-none.tar.gz=7a38813bc6e79b34ea4d8465ae0134c22886516be427e61a5ed8d823adbbfb60 +dist/2026-11-10/rust-std-beta-loongarch32-unknown-none.tar.xz=14764534ff9f5d6af42d6e26a19688c718239129c6b78dbccd1a78bfff311379 +dist/2026-11-10/rust-std-beta-loongarch32-unknown-none-softfloat.tar.gz=e90aafdb0ccf2975e855099dfa98e59e51047325648e71bbf9692548ab5312c1 +dist/2026-11-10/rust-std-beta-loongarch32-unknown-none-softfloat.tar.xz=b3ac937114f83164ba676c59c91da3147c35c8e8820befc50477a806cf1cf9bf +dist/2026-11-10/rust-std-beta-loongarch64-unknown-linux-gnu.tar.gz=44251d1312049f2517be174b4991de61fc688847d703310c35ea86338f6b9263 +dist/2026-11-10/rust-std-beta-loongarch64-unknown-linux-gnu.tar.xz=a1a6874efc14075c80e3cd1cdd34e7643c134eb47693f2cfc846303339c32cec +dist/2026-11-10/rust-std-beta-loongarch64-unknown-linux-musl.tar.gz=9c85618d477b205d4237b9aeebff855208ac260d0c205e46c9493a681f457ac1 +dist/2026-11-10/rust-std-beta-loongarch64-unknown-linux-musl.tar.xz=dffcb2e8b77caec45684b6a898c090615ad7df686cd293a754d90682b25bae1c +dist/2026-11-10/rust-std-beta-loongarch64-unknown-none.tar.gz=c24cefbbe3a76833c234f2fbd5afefaa4631537a3caa92404523b8246af62fa5 +dist/2026-11-10/rust-std-beta-loongarch64-unknown-none.tar.xz=8108e4073b63e8f465e360d530481ac7634497e1757f10206b9f934b26ef4480 +dist/2026-11-10/rust-std-beta-loongarch64-unknown-none-softfloat.tar.gz=e9d6462178b57580f7881666f2aaccff7037943a9720f1a84ab8f52031da967e +dist/2026-11-10/rust-std-beta-loongarch64-unknown-none-softfloat.tar.xz=f257eb975ee814b2f4da8676048aa440cd32ea9e174b15cf640afc88e4b552ca +dist/2026-11-10/rust-std-beta-nvptx64-nvidia-cuda.tar.gz=c90924fb7c17c1168dd96cb88a42411eb3af7f106a0cc5f844e722dd9fd2a694 +dist/2026-11-10/rust-std-beta-nvptx64-nvidia-cuda.tar.xz=d775cb5351494cbd7cc79c62bef4882922846987c31eec1ac8915c71b82f09a9 +dist/2026-11-10/rust-std-beta-powerpc-unknown-linux-gnu.tar.gz=6baeafda050304dca8d6e9ee352aa13dad07e90e3e2436a8664cf2b5a1572e95 +dist/2026-11-10/rust-std-beta-powerpc-unknown-linux-gnu.tar.xz=99e313fcca5de37d6fc6eddc47b51377dcd75ae8b609e520b56bd8e54236ece7 +dist/2026-11-10/rust-std-beta-powerpc64-unknown-linux-gnu.tar.gz=23e5f1b901e2ef2ec955188da6127802659d11543948267dd97fe6430d7ec5e7 +dist/2026-11-10/rust-std-beta-powerpc64-unknown-linux-gnu.tar.xz=85baf134b9a98ca52a8c2211a5f928f8e6b2913d5eb76e630853d51fe35fd923 +dist/2026-11-10/rust-std-beta-powerpc64-unknown-linux-musl.tar.gz=404c831f03a3480565f19deccafee3ae46736eb63b129d164ccf9e1cf553cec5 +dist/2026-11-10/rust-std-beta-powerpc64-unknown-linux-musl.tar.xz=354289735da9caf1d21f99708c1a025ad8966e5833543f52d242d205d9c06fcf +dist/2026-11-10/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.gz=9faa0bb018d58ea2aa715c742d949c1fff021fe1f413afb612f635c1714ceb8f +dist/2026-11-10/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.xz=f493ce8f1c96d1a81bf9d2e4bdcd5644dafd6dccc4d0b80a0391d10d339a8fff +dist/2026-11-10/rust-std-beta-powerpc64le-unknown-linux-musl.tar.gz=c1fcd70be5442df14c47bf7e313f65c35bfaebe4b3d837be8db3aa733b811bf0 +dist/2026-11-10/rust-std-beta-powerpc64le-unknown-linux-musl.tar.xz=1ebdaf275a275b63bb66459ab832caf117779fab31d00da33fd8db5c5b0a1674 +dist/2026-11-10/rust-std-beta-riscv32i-unknown-none-elf.tar.gz=d42d0c4e6a19212614681624432d6f4618cf3c5b99c2e320ef6e9d13e0562d45 +dist/2026-11-10/rust-std-beta-riscv32i-unknown-none-elf.tar.xz=b5c05cdac53e16c0442a8866a0c73f473637f108a37d0ea564bc1d9d7d0dc1a2 +dist/2026-11-10/rust-std-beta-riscv32im-unknown-none-elf.tar.gz=d1547c90911d0f8fb9dbe779ca0990a8e5ddfdb8f3707742ae71245f27f186e2 +dist/2026-11-10/rust-std-beta-riscv32im-unknown-none-elf.tar.xz=f9a598752cb2e043c137b8886dc54823d47784ddc542e3c936ecc3716be52513 +dist/2026-11-10/rust-std-beta-riscv32imac-unknown-none-elf.tar.gz=e0e361f4e119befd96b921dc431310624c01de1d61b334a8da6ef461ab6afd08 +dist/2026-11-10/rust-std-beta-riscv32imac-unknown-none-elf.tar.xz=10a8aff121ec61e5f34a2397a9c836db9c50fb473b72676476950b44290f9edb +dist/2026-11-10/rust-std-beta-riscv32imafc-unknown-none-elf.tar.gz=0225a79b8ad2f93273740540a816fee7d1ecd401a8b9ad8161ce4fc2d438c797 +dist/2026-11-10/rust-std-beta-riscv32imafc-unknown-none-elf.tar.xz=a765e692cef352162ffcf34a88903702381b31a5a1d48224e18a7840947b1484 +dist/2026-11-10/rust-std-beta-riscv32imc-unknown-none-elf.tar.gz=131fa72f1aaaecc9175663ae284329513b0c517277e14bf0094a37408d4d3469 +dist/2026-11-10/rust-std-beta-riscv32imc-unknown-none-elf.tar.xz=c14a12c6a3412ee188bc6012ed15cf6aa1a74802516070f03e09790f5fd1cb3c +dist/2026-11-10/rust-std-beta-riscv64a23-unknown-linux-gnu.tar.gz=2361641f1abc374d1b2d9cd7d4298891a7656679849dc16a7e77fdd928b2b42d +dist/2026-11-10/rust-std-beta-riscv64a23-unknown-linux-gnu.tar.xz=a73dcd39db92a5f20e71b30550f2f9e60037f31327f734ef62a1b5ab638ad49e +dist/2026-11-10/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.gz=0212ab52064e5e4eee318596d1bf1024989725421300642363224e2cbc8092b4 +dist/2026-11-10/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.xz=8c45482604ada05ec202ac5d07424dd3e4ccbf07cc7f6697112ff0eec9e553f5 +dist/2026-11-10/rust-std-beta-riscv64gc-unknown-linux-musl.tar.gz=1bc2a4d3e41ebf3f37aada9700c88fa7b49194e5b831b416194f69e2dda62a8f +dist/2026-11-10/rust-std-beta-riscv64gc-unknown-linux-musl.tar.xz=1c2528fe495aea63b92683f13b7d336f57d2fe63c23ee8feb0d73bc15f6a6b66 +dist/2026-11-10/rust-std-beta-riscv64gc-unknown-none-elf.tar.gz=b2850a5aed83b9ae5ea1920378bca75f873c179226cbaf7384efc240c4fa6620 +dist/2026-11-10/rust-std-beta-riscv64gc-unknown-none-elf.tar.xz=d2a13438055059f1a18b7faf42d5106f9bd325ebec14190c8752f8051ad167f0 +dist/2026-11-10/rust-std-beta-riscv64imac-unknown-none-elf.tar.gz=02744ca3f59f7ca3fa0d870ea907e1c72bbc8970788310ad5149fc88bbe175ca +dist/2026-11-10/rust-std-beta-riscv64imac-unknown-none-elf.tar.xz=72aba2c41d21826d5b51e864a5dab47f17182f592349f99f37be48c9663c15fb +dist/2026-11-10/rust-std-beta-s390x-unknown-linux-gnu.tar.gz=9a0b379caf4134772e850993c6d1ea68c01263c8a0355b5efacea4164b150d7a +dist/2026-11-10/rust-std-beta-s390x-unknown-linux-gnu.tar.xz=cba557bc9cf49ba90a671a187e79f1e859ce1c50201f0d01eec8384c847dd8b1 +dist/2026-11-10/rust-std-beta-sparc64-unknown-linux-gnu.tar.gz=63962fd13834d3c0ed4675c8311c32397db6334ead916abaced3c7ffd5986b37 +dist/2026-11-10/rust-std-beta-sparc64-unknown-linux-gnu.tar.xz=8968627e26dfbf0b31683d3b9d9d4c8d66f3d11552da66d8ba6ed803348952b4 +dist/2026-11-10/rust-std-beta-sparcv9-sun-solaris.tar.gz=e9670588524a6153300481feb9bc39abbe38f9c4f94bb24aba7b2dbc942a4cfa +dist/2026-11-10/rust-std-beta-sparcv9-sun-solaris.tar.xz=eb4727da50ffe60de2791ae711678e89e59e52b9ff8ba69686b254cb8afb7d89 +dist/2026-11-10/rust-std-beta-thumbv6m-none-eabi.tar.gz=57c16d2cd4cf5f8c92a369d846e4d5080632f508fd25a3ff7ed5cef1531c73cc +dist/2026-11-10/rust-std-beta-thumbv6m-none-eabi.tar.xz=89a6fa8b98f584d457743d30349b0cb3d738cfc5c1a81481545b1afa86ab04bc +dist/2026-11-10/rust-std-beta-thumbv7a-none-eabi.tar.gz=38d9d5d44de1332e1571befc2a0f6d96394add341d899336bb66858fba97155f +dist/2026-11-10/rust-std-beta-thumbv7a-none-eabi.tar.xz=4ddacdf89ff4730b7626c315b899275a680a8c4f79a42dcc3239c8713139abd5 +dist/2026-11-10/rust-std-beta-thumbv7a-none-eabihf.tar.gz=f2913cd2230e6f1db779db73cbd1d06c59ddaec0ad062dc2069b569e1cd4b1d7 +dist/2026-11-10/rust-std-beta-thumbv7a-none-eabihf.tar.xz=f7e74ed0cedf716a68910a1ef6dead2a56666fc77fd387dbcd7fdcb978ebfbe5 +dist/2026-11-10/rust-std-beta-thumbv7em-none-eabi.tar.gz=aa43a9f1e04489df399c1d1ed682d694456198f50f9b99decb885a3edf818437 +dist/2026-11-10/rust-std-beta-thumbv7em-none-eabi.tar.xz=123a92690614bd4f1fdd91baf50b1ef090c9dd61b27824e871d78b8d4edc5b5a +dist/2026-11-10/rust-std-beta-thumbv7em-none-eabihf.tar.gz=f94c21b4ff57978fc29e8cb8eab7436b281fb743ba2f591c367135530648824b +dist/2026-11-10/rust-std-beta-thumbv7em-none-eabihf.tar.xz=a57f0cb944282d45f9f900687f0cbaefcc28b1a55c841957c87908d17ab5fc77 +dist/2026-11-10/rust-std-beta-thumbv7m-none-eabi.tar.gz=336d8c8b4694ae7624f4184189ecbd84c0efd1c20ec60386b6f326a50cdb1c3e +dist/2026-11-10/rust-std-beta-thumbv7m-none-eabi.tar.xz=3ad1e7d2fb6f2826bd8dcf341ca4add4642cf0e7b75434f8a2f8964ad2437c72 +dist/2026-11-10/rust-std-beta-thumbv7neon-linux-androideabi.tar.gz=a48d3a664594dbb7dfc82727c065be9c3652ee0f23bdbd325da9a9b356ed7207 +dist/2026-11-10/rust-std-beta-thumbv7neon-linux-androideabi.tar.xz=c79acf953c0b87e23e47cc83523a710af56a2360f3c0ac4a952ee130561a48c4 +dist/2026-11-10/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.gz=4caabd93dab49d8e8b9bbab1322327b9ca56de5a81709613fd162cddde1e9ddb +dist/2026-11-10/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.xz=2b2927e44f4d76ae23ad9034d7daf4408e96a3c1cda0cfa625e490591b399622 +dist/2026-11-10/rust-std-beta-thumbv7r-none-eabi.tar.gz=e17f5a02fd512fd6528e98c5afe7bfa77b7931807206609209d3ae5bdd0df4af +dist/2026-11-10/rust-std-beta-thumbv7r-none-eabi.tar.xz=9b9f3c4b3b9773b731bc0a5f90712bab62d257441636944346bdb74df0ff6193 +dist/2026-11-10/rust-std-beta-thumbv7r-none-eabihf.tar.gz=d34dc5574ebe2e47abd96cac1319a5fbaddec482ab4f71d568bd8269f1adcd45 +dist/2026-11-10/rust-std-beta-thumbv7r-none-eabihf.tar.xz=72466af074e701918048f54840d3c536c6e94f42c0f0813a2607d1125c99dc54 +dist/2026-11-10/rust-std-beta-thumbv8m.base-none-eabi.tar.gz=d297eb283dc9f9ebe12784b4cecad0c89259a4acc76c6a35ecd14acf5584f498 +dist/2026-11-10/rust-std-beta-thumbv8m.base-none-eabi.tar.xz=88a9035b1beef004f2146cbe1c00d96107df1a6f3019535af9168eb26435f13c +dist/2026-11-10/rust-std-beta-thumbv8m.main-none-eabi.tar.gz=b0c085e28c370a23a797e4a658590eb229ca7d624a9e1af69c389ba44d77ccc4 +dist/2026-11-10/rust-std-beta-thumbv8m.main-none-eabi.tar.xz=11f03b596794ee5a5e1315d53408dbe117b13fb1ee13b776be514f3ace8fc0cc +dist/2026-11-10/rust-std-beta-thumbv8m.main-none-eabihf.tar.gz=0ce398ca0134d194136d4f147a42fdf893df3d5c1fad5fddc9c42071906e617e +dist/2026-11-10/rust-std-beta-thumbv8m.main-none-eabihf.tar.xz=62adc35edb0eda29ce66a243a7e048c761c5fbc25dea09d4668d1da9961e5db9 +dist/2026-11-10/rust-std-beta-thumbv8r-none-eabihf.tar.gz=6fa8d07b247b920c2c9442de42c72da130c64285f6d91fae4aee47c93ee60701 +dist/2026-11-10/rust-std-beta-thumbv8r-none-eabihf.tar.xz=28d6364b34d61f3d91c0fc17c7167875c7d214b683692ad83428ff0740a04ba2 +dist/2026-11-10/rust-std-beta-wasm32-unknown-emscripten.tar.gz=72932782efa8ee98232a181ea18b1c2e1027bf7047dc2f20ac2caeacecf122f4 +dist/2026-11-10/rust-std-beta-wasm32-unknown-emscripten.tar.xz=3ce669d1a9c71417844a9ca65e68d447ee45f8b94115c8c31197ca0a891d7ab9 +dist/2026-11-10/rust-std-beta-wasm32-unknown-unknown.tar.gz=4d774641790e1e76b2639b596395c9fcce09d8b260ae0c32c0554a11c4171cfc +dist/2026-11-10/rust-std-beta-wasm32-unknown-unknown.tar.xz=4d6b532d6b7bbbe2906fa457c612903faf0567aed20a8facc5a51f28497b8d5e +dist/2026-11-10/rust-std-beta-wasm32-wasip1.tar.gz=61451721305e08e0933b1e03a772c487dc3cb3fed5ea8b8d4d1e711b0deda28a +dist/2026-11-10/rust-std-beta-wasm32-wasip1.tar.xz=567c10b384fd4afe058dcbfb7130295f7fb1300d6d7908ce4505f133153cac57 +dist/2026-11-10/rust-std-beta-wasm32-wasip1-threads.tar.gz=4294c7b0d9d350f62948ff5930283998a3693a288d386d19f5846dac4d897064 +dist/2026-11-10/rust-std-beta-wasm32-wasip1-threads.tar.xz=a5da17aad0dcefc95da608f9697d60845020d55f3e0608b6213632bb3077d6c1 +dist/2026-11-10/rust-std-beta-wasm32-wasip2.tar.gz=d6795335b57f7ccc8f40b750318ac5e91d884c3f2183dc1b7dbf16ccdf323fa7 +dist/2026-11-10/rust-std-beta-wasm32-wasip2.tar.xz=6132271ef170fd98e9ed904e788785c49496d605f6d6844c0246e46abdc543d4 +dist/2026-11-10/rust-std-beta-wasm32-wasip3.tar.gz=d4a9f7dcdf893b02dd8074247328d3fb128a6b1083ba86b4a9a91fda5a0fa03a +dist/2026-11-10/rust-std-beta-wasm32-wasip3.tar.xz=6851c0449327f4911460de69517bbe2ed3e03add3aa5cca64768cf3980544441 +dist/2026-11-10/rust-std-beta-wasm32v1-none.tar.gz=b8f49f3f03c13d99c8e62a573a13c26256996352812c81ba334283343c91bad9 +dist/2026-11-10/rust-std-beta-wasm32v1-none.tar.xz=c56f5c4bdb2ccbeaccac504841ae805de6eb848307cf94b1305f80b449fcca50 +dist/2026-11-10/rust-std-beta-x86_64-apple-darwin.tar.gz=de6a45f43e649b5ace2ca9a42b720d728e832f895c3bb80a292cc413825e2dad +dist/2026-11-10/rust-std-beta-x86_64-apple-darwin.tar.xz=2fef7b1c2fe968e927e962a2ed14ea9d7c87ea9ba002ae26e81fd002df68ac14 +dist/2026-11-10/rust-std-beta-x86_64-apple-ios.tar.gz=7b37a43d24f7460709a8cce06906cd964b8f58328bc8fe6d80fd7db9cb1ffc66 +dist/2026-11-10/rust-std-beta-x86_64-apple-ios.tar.xz=86d0122af744b9362b9401828ad894c8084ad43c3cb8a1be4f8060ad1e35d160 +dist/2026-11-10/rust-std-beta-x86_64-apple-ios-macabi.tar.gz=705c1fdb6f5f764a611cb09420108dd6a833560776ea329f77e0b70d771e4061 +dist/2026-11-10/rust-std-beta-x86_64-apple-ios-macabi.tar.xz=1c305bb0aa991eff8bf37d74b15cce57de8a985266f5d9dc99e59586ea6d4b24 +dist/2026-11-10/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.gz=386c1f141461151ed0db349e7077e57b5ddf29f807f97342f7e8598f32854a15 +dist/2026-11-10/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.xz=777a477667e5897167e0f9c6410b8245d8171beb98f60e2aa61e6e0d34e54fae +dist/2026-11-10/rust-std-beta-x86_64-linux-android.tar.gz=f9500717b174a11fb9e7f06bd671973c7e2f331a3662a716373e7177d423508f +dist/2026-11-10/rust-std-beta-x86_64-linux-android.tar.xz=7ed231573119e68d9d4f1c9d2762717bf01d4b2d27b5e7df4db5daa712a0b5d2 +dist/2026-11-10/rust-std-beta-x86_64-pc-solaris.tar.gz=a3f7ea5cf7cfcd0ff64d71b727c9c03fef162fbc4d5154d60bac4e45e8186223 +dist/2026-11-10/rust-std-beta-x86_64-pc-solaris.tar.xz=441b09467782a6940dc439598c048d21b1bb417f9a16ad7b30fd848fcec3249c +dist/2026-11-10/rust-std-beta-x86_64-pc-windows-gnu.tar.gz=f05e7e4cd0a025416c09842780b63032596244d16ff493e492ebfac3740b258d +dist/2026-11-10/rust-std-beta-x86_64-pc-windows-gnu.tar.xz=772d84a3869d509201a5a5fa2d0fab3ff9b7fb9b726a188b27eca51b51237302 +dist/2026-11-10/rust-std-beta-x86_64-pc-windows-gnullvm.tar.gz=abf6a3cef49e7dd85cf4e91b3dc7fe7668305d27636031e9a95e1d4ea67e0645 +dist/2026-11-10/rust-std-beta-x86_64-pc-windows-gnullvm.tar.xz=07aaf6974d191db5d4008f58fa0c16a217f51a10717c6e97c0ac67a547faa956 +dist/2026-11-10/rust-std-beta-x86_64-pc-windows-msvc.tar.gz=bc3c312bf6a18069aaa596bf1deb733dd2281bc35bc13312017bcb5a866342e1 +dist/2026-11-10/rust-std-beta-x86_64-pc-windows-msvc.tar.xz=172a49b0c1c70ab4a889b8d63128de425ac9af26e370d732267d4b04a8ea06b5 +dist/2026-11-10/rust-std-beta-x86_64-unknown-freebsd.tar.gz=2e3a3e4f7e87751664fcf716eb81f78c0b964d3d33416ee9e4a1707ce6ee71be +dist/2026-11-10/rust-std-beta-x86_64-unknown-freebsd.tar.xz=0f5408a1c5977b42a76326d746f3cb503597073781b878c3311a5f8eaed357a8 +dist/2026-11-10/rust-std-beta-x86_64-unknown-fuchsia.tar.gz=b7ec08658fd54e21ce6a68d8227d63d38183eaa978260df6aa90a51d19e0450a +dist/2026-11-10/rust-std-beta-x86_64-unknown-fuchsia.tar.xz=fccafe07a2bd9a33c870e40a8dc5f0d374576c53e129805d70122e921d94657c +dist/2026-11-10/rust-std-beta-x86_64-unknown-illumos.tar.gz=a7ef34b2b26d76f6eaf0fc9c3364c66033cffaaadb79eeeedc7bd3c041f2bc49 +dist/2026-11-10/rust-std-beta-x86_64-unknown-illumos.tar.xz=6102919b353a2c8a5ce1b5ba7cfa96b1a509f586f98e1c0a00d8ce908edc96f5 +dist/2026-11-10/rust-std-beta-x86_64-unknown-linux-gnu.tar.gz=25518cc7372f2445bb3caca3716608660318c83388e83f9a6d30e9c8be286ce7 +dist/2026-11-10/rust-std-beta-x86_64-unknown-linux-gnu.tar.xz=8a45bfff9de01fb5dcbed0170dd4e6ef902ac1631bacde0e4ad35c002b97eccc +dist/2026-11-10/rust-std-beta-x86_64-unknown-linux-gnuasan.tar.gz=3d1a7c9f7727296d5177173134446687d83f15a523e1fc1e9ba98a5f69dc57fc +dist/2026-11-10/rust-std-beta-x86_64-unknown-linux-gnuasan.tar.xz=5dbc523172879c58575e83fcb7ce6de6829ffb02b08dd63f3437695bbf7a31b0 +dist/2026-11-10/rust-std-beta-x86_64-unknown-linux-gnumsan.tar.gz=7b4d320d71438607a0974b611ef61f058ce5bb411477dc89792981bd88d2052d +dist/2026-11-10/rust-std-beta-x86_64-unknown-linux-gnumsan.tar.xz=3e2c198bfb7989172f7e4dfcc2de0f345d3c7ddb00ad85a56b39c7777b362874 +dist/2026-11-10/rust-std-beta-x86_64-unknown-linux-gnutsan.tar.gz=0f3141ae263352e1dbf3c39a16a9b9e91757c3436d09ecdc0269581d9de6cba4 +dist/2026-11-10/rust-std-beta-x86_64-unknown-linux-gnutsan.tar.xz=725fc06999865eb4bf1fdab8fcd5469cea972bd83280dcbd63838df39c2e57b9 +dist/2026-11-10/rust-std-beta-x86_64-unknown-linux-gnux32.tar.gz=3cc11adbe67862a2b00c5b0973fa1458dbadbb44f69a09b79f90019be8a61949 +dist/2026-11-10/rust-std-beta-x86_64-unknown-linux-gnux32.tar.xz=a0ccc1ab0f88d59e3b5e7108780e11bfde1028d0fde1a4a743feba727c3b7228 +dist/2026-11-10/rust-std-beta-x86_64-unknown-linux-musl.tar.gz=118ae248e647382b5159b8b370924e9c8aa7ba3d3470fdb4b6f2870326536ac3 +dist/2026-11-10/rust-std-beta-x86_64-unknown-linux-musl.tar.xz=0e822ec40bea498416f9f03a6ff6940bba63c48cd8b443c5624931222a04dcb6 +dist/2026-11-10/rust-std-beta-x86_64-unknown-linux-ohos.tar.gz=88fd1565cc69912804ef9f4fdb0852b5072d3f39cb64154a8da72d14c36900c2 +dist/2026-11-10/rust-std-beta-x86_64-unknown-linux-ohos.tar.xz=d9c5241ddfb2d03bb72b6af8f73194d1aa1ff7c6672dbcdad3951e1d45a86cad +dist/2026-11-10/rust-std-beta-x86_64-unknown-netbsd.tar.gz=f538f70000ef8daaef32430a85f6befda73574f206173f5aef7ac4476ed34d1b +dist/2026-11-10/rust-std-beta-x86_64-unknown-netbsd.tar.xz=0e59750285bb2243da163b1581d0fa60ea4b7739ec59f633e48a337559c6efec +dist/2026-11-10/rust-std-beta-x86_64-unknown-none.tar.gz=71030d6d6169238218f0242fae55c8cc504f5e5c4ebab84dd57e79fedadee073 +dist/2026-11-10/rust-std-beta-x86_64-unknown-none.tar.xz=f7f467bc772b80bd1ca039de4e41df3a1ec4a9fba30fa3ff31399db2fef2769b +dist/2026-11-10/rust-std-beta-x86_64-unknown-redox.tar.gz=2fb5d0cf8aee9943d5dc24a4a22619ed0d824a10a71114cfa70d8af019bcc47b +dist/2026-11-10/rust-std-beta-x86_64-unknown-redox.tar.xz=d04ab596b210ba289a138f710e0a7a6d775f226b27068d6e01eaa499524162e4 +dist/2026-11-10/rust-std-beta-x86_64-unknown-uefi.tar.gz=bc9b8626037c43ba3e3ac963eef2758040f4b5e4a30ad21d253fa44f279ffdf5 +dist/2026-11-10/rust-std-beta-x86_64-unknown-uefi.tar.xz=2977a2356092d2a064b8b5bc6df6eabb017f3b25730fd14a30c26c75555e5213 +dist/2026-11-10/cargo-beta-aarch64-apple-darwin.tar.gz=f79e2667c5d15256ebb623a20a446366e10569fba0d23d6226315bd8888e4b7d +dist/2026-11-10/cargo-beta-aarch64-apple-darwin.tar.xz=1de36ff8d8f0566d0901cb7b8eee2437e8c5f32c427d86fd811cd90411f5e436 +dist/2026-11-10/cargo-beta-aarch64-pc-windows-gnullvm.tar.gz=e930ae3fa359ebda61797979c86392ed9bfce1ef1d7be522ae2d5c5d667031be +dist/2026-11-10/cargo-beta-aarch64-pc-windows-gnullvm.tar.xz=69a393f9c0bea1bd742765a68aa23f2aa43d3cc819d80b1f64bfafc67271c777 +dist/2026-11-10/cargo-beta-aarch64-pc-windows-msvc.tar.gz=ecbd44fe6457bb8383c9b28cbdce0ffd5878b9b1828efd343a8175a884b505b3 +dist/2026-11-10/cargo-beta-aarch64-pc-windows-msvc.tar.xz=193be6a89a5559dd8ada2613d9d7a9ee07e3c3e3f2cb2670d2ceb786c8777da3 +dist/2026-11-10/cargo-beta-aarch64-unknown-freebsd.tar.gz=18a9f6ecb5423207662c6fc3c3059971c40cafceead70f8e5fdc6da2f07b241f +dist/2026-11-10/cargo-beta-aarch64-unknown-freebsd.tar.xz=b627272b2b9234ba8430889eb0d5d63fd3b75c188609de863e1531c0f505c6d8 +dist/2026-11-10/cargo-beta-aarch64-unknown-linux-gnu.tar.gz=ea37fc1fbebff11420e2433592a7a41647de908a0e87e7893e2a978f19e9127f +dist/2026-11-10/cargo-beta-aarch64-unknown-linux-gnu.tar.xz=f9ef71354be05a9df6ef6701738f6ea716870bde82cd7a3f2695c4bab66e160f +dist/2026-11-10/cargo-beta-aarch64-unknown-linux-musl.tar.gz=90eeff67b7dd99d96e3db006b0e207849a8babe4805e8da6476d25e231b0253b +dist/2026-11-10/cargo-beta-aarch64-unknown-linux-musl.tar.xz=615078359453b9a1a0ddd37000169664aa57923d8e655ab8fd371d0a9a0fd381 +dist/2026-11-10/cargo-beta-aarch64-unknown-linux-ohos.tar.gz=6fdbd81f77efc91453d68db8a903cfc08ad7f14d9f5f669ccb0008bc71ef996c +dist/2026-11-10/cargo-beta-aarch64-unknown-linux-ohos.tar.xz=d04ea3b920fc8105fb64bdf571618074b9f77b8056aa1c89cb553167e0f514f8 +dist/2026-11-10/cargo-beta-arm-unknown-linux-gnueabi.tar.gz=20ff406435fed6e0f9ba2a71e50daa1e22d467bf353e8a5c34a8a98bd8807476 +dist/2026-11-10/cargo-beta-arm-unknown-linux-gnueabi.tar.xz=11a99bc337477c4c2d85c00f8d8ac65c7bda206a41f6f025255a2f0dcf7a34d6 +dist/2026-11-10/cargo-beta-arm-unknown-linux-gnueabihf.tar.gz=3dd95f939a8e1bd598803433e1a4bea17e4846416e947e1e66c3a98a9cf82e31 +dist/2026-11-10/cargo-beta-arm-unknown-linux-gnueabihf.tar.xz=7c4b16f18517e604c3b3239739059396e1f3b218ee9b3ba11184c280be6feb3a +dist/2026-11-10/cargo-beta-armv7-unknown-linux-gnueabihf.tar.gz=cd4aa556a50e0d9a9c4f54e9c2109e9ac5a25d5ef21dfa2451966a2b8288278d +dist/2026-11-10/cargo-beta-armv7-unknown-linux-gnueabihf.tar.xz=8365bf02c097dd0cf88578583309556e43919c7f964d6c1ddfd9b35c98c9c037 +dist/2026-11-10/cargo-beta-i686-unknown-linux-gnu.tar.gz=82e6bccb75c0e429f0dfceea8b4fcc442aaa719855b6fcc633df4f6f55a84e04 +dist/2026-11-10/cargo-beta-i686-unknown-linux-gnu.tar.xz=378a0569e2efe63efd843339c3ba2b88ca5652a188bca0225478998722503966 +dist/2026-11-10/cargo-beta-loongarch64-unknown-linux-gnu.tar.gz=498bebc978336ef8cf09219ff1ddebd83b1db21a8b2471f68a2467d0bb55e9da +dist/2026-11-10/cargo-beta-loongarch64-unknown-linux-gnu.tar.xz=bbecec4d1928f133ef8a2267842714e9bf1cad3acb2e8e685881a133f3589486 +dist/2026-11-10/cargo-beta-loongarch64-unknown-linux-musl.tar.gz=04b9c9ce128a07f93e043446269829673100a79be5c9b8b13b35e34bd2bb3387 +dist/2026-11-10/cargo-beta-loongarch64-unknown-linux-musl.tar.xz=a3cb5a7cedf707c820b6555a1401742478829972cf09f2f44465e7ec255652f3 +dist/2026-11-10/cargo-beta-powerpc-unknown-linux-gnu.tar.gz=49e84ab7d11681af2def2e07e461a75fd80832d13038b089b3040baa04d54da7 +dist/2026-11-10/cargo-beta-powerpc-unknown-linux-gnu.tar.xz=d759606d2c7427930a0c36a736b8cb037cebbaf3fe88755ba9062a486d5b6b59 +dist/2026-11-10/cargo-beta-powerpc64-unknown-linux-gnu.tar.gz=ab348f723aabc08b77a7493baeedc815943a9e41d460c61d984940d546776394 +dist/2026-11-10/cargo-beta-powerpc64-unknown-linux-gnu.tar.xz=e7d8f8fc22819c46dc23493993177cafb45d324d3b3fed14ca56e00c79ac1f42 +dist/2026-11-10/cargo-beta-powerpc64-unknown-linux-musl.tar.gz=c28b0e2c23edf031134d724100c85700055c09096a800849dc158a9b15704ba5 +dist/2026-11-10/cargo-beta-powerpc64-unknown-linux-musl.tar.xz=ca60fa2f90d34fa0b2b3bedffdec78c40b648ed0f78c042e5388b0b56e368d75 +dist/2026-11-10/cargo-beta-powerpc64le-unknown-linux-gnu.tar.gz=1a1202bc9380e13f02b96865344aa1e5b0ec09c7cc0baf386fb1ae1e34a7cb72 +dist/2026-11-10/cargo-beta-powerpc64le-unknown-linux-gnu.tar.xz=b5f8259fb7fbb364f9bce8a03597ad5d9b677ae5ec63966ea63f6cd416429623 +dist/2026-11-10/cargo-beta-powerpc64le-unknown-linux-musl.tar.gz=765415587ca3b4fa47c35d956090b2ae35057d75643941d772c0f3a535c03f51 +dist/2026-11-10/cargo-beta-powerpc64le-unknown-linux-musl.tar.xz=61f654567d3215ee755422a0c50290d88d0c3baa5c0aa4c51e47ada1b3a2bc25 +dist/2026-11-10/cargo-beta-riscv64gc-unknown-linux-gnu.tar.gz=5b0d8bd269e08e018a6a09383be14833df3d6c38a57fd5b25b6a415e628ab5e1 +dist/2026-11-10/cargo-beta-riscv64gc-unknown-linux-gnu.tar.xz=fa375cfa1d49edd7bfec2126385e0d2b53e151596ca852004b4b124b03b546ee +dist/2026-11-10/cargo-beta-riscv64gc-unknown-linux-musl.tar.gz=42312338dd2a0874aa34b1fad9f9091dd90b972ae8f365b531df2a053e8faeda +dist/2026-11-10/cargo-beta-riscv64gc-unknown-linux-musl.tar.xz=8527dc2f026cd9859c89c286c507807536f3e3397e37c4f5804f9fc569924fb3 +dist/2026-11-10/cargo-beta-s390x-unknown-linux-gnu.tar.gz=673574dcb15a6de2a4d617ed6d1d6c083395d45823dd33d2bdd0c4c868395ffe +dist/2026-11-10/cargo-beta-s390x-unknown-linux-gnu.tar.xz=c8cffc46eb2b7e80636fd3b8cfa819d5bfb47404f0b7137f1fd3b3a9790db690 +dist/2026-11-10/cargo-beta-sparcv9-sun-solaris.tar.gz=d630767dd32978ed86848b69fe55e49b745f28de05750ab258efdc4aac6416e9 +dist/2026-11-10/cargo-beta-sparcv9-sun-solaris.tar.xz=5b3ca6ac179e441120c18081da602390153d3192563ca1aca7d1817bfe90b32a +dist/2026-11-10/cargo-beta-x86_64-apple-darwin.tar.gz=f11767edb6a1ed8026e65e09643256dceda788bdfb0083b410832b0cf43e045c +dist/2026-11-10/cargo-beta-x86_64-apple-darwin.tar.xz=39d57ebb8941a374d3ba2f29e4a0aea55fce72d8fa3420988d868b96c614c06f +dist/2026-11-10/cargo-beta-x86_64-pc-solaris.tar.gz=99d8c312e2cd58534765fb5b180a020a93ca3b15dacb730a71ff7e1c42e50bf0 +dist/2026-11-10/cargo-beta-x86_64-pc-solaris.tar.xz=2d3e61a40d2f28aecd21898749ac4dd64a8ede12f22a95e18b6456f7bab238d0 +dist/2026-11-10/cargo-beta-x86_64-pc-windows-gnu.tar.gz=fb37a13a93563b71955abe4777ce65e0ae67789996664e18f0167e10eb4b6263 +dist/2026-11-10/cargo-beta-x86_64-pc-windows-gnu.tar.xz=257559daa73b78b590c4d7dbe949a6ad47c28e3023443b60babf9790c80b04f0 +dist/2026-11-10/cargo-beta-x86_64-pc-windows-gnullvm.tar.gz=6754c7ef8e629cee874a82546e394a6107a045490bc5765b13f9843a116533b3 +dist/2026-11-10/cargo-beta-x86_64-pc-windows-gnullvm.tar.xz=55b0c4dce59fc22dcb45d7f920caf936012610f1cc2edee0f924a167eb0ed45a +dist/2026-11-10/cargo-beta-x86_64-pc-windows-msvc.tar.gz=da63a0df454c627aec00d8c34302c709cc75afbd55412b6f86c48e1f2e9af8f6 +dist/2026-11-10/cargo-beta-x86_64-pc-windows-msvc.tar.xz=298827adef7511248291c4c3d83ec607d24e1c28710eee41d86c93b6a9459f42 +dist/2026-11-10/cargo-beta-x86_64-unknown-freebsd.tar.gz=5243fd3f3c825a6f35c2908ee412cab25c1ef5220c8d2c14c858ad719a388400 +dist/2026-11-10/cargo-beta-x86_64-unknown-freebsd.tar.xz=d7dc3d6a5d967ef4a103c7643c30e92ec56f45a20e1ca79ebe0724e599d4630d +dist/2026-11-10/cargo-beta-x86_64-unknown-illumos.tar.gz=69dacdfa070d26e3a6e1433b0b4880ba70f41b45534dcd1adb708ac7aa631fe9 +dist/2026-11-10/cargo-beta-x86_64-unknown-illumos.tar.xz=7ba1444f1a5e44bd42572b8ea8f6bb392a436bec9285a4eb624d35895fb98e0f +dist/2026-11-10/cargo-beta-x86_64-unknown-linux-gnu.tar.gz=40955fc24b8e18acd0b5368b097ef0d49f42c247ba98a517e8cd33aafa920b32 +dist/2026-11-10/cargo-beta-x86_64-unknown-linux-gnu.tar.xz=fc6ed6fea4725ee26ce3749863548ff1cadb9b0407cd9117af4311ddfbb3812b +dist/2026-11-10/cargo-beta-x86_64-unknown-linux-musl.tar.gz=2d0c4ced1e490fab88035597e722cdfa1736750d69681a3dde2580b874ef1cf2 +dist/2026-11-10/cargo-beta-x86_64-unknown-linux-musl.tar.xz=8dba78f9af8b06c03c916bdc8599b027191528200efea4bef7235bb2254a3ccd +dist/2026-11-10/cargo-beta-x86_64-unknown-netbsd.tar.gz=3de438b60ea849e5d78906fb50611a8c725370415e0baa40f6f256e1f348f6a9 +dist/2026-11-10/cargo-beta-x86_64-unknown-netbsd.tar.xz=9b9890d644348fba75aa6751835460cf845c780f6e6868d910eef6e14984a930 +dist/2026-11-10/clippy-beta-aarch64-apple-darwin.tar.gz=41723fa642c258ae32da0fc07691c13a179ed7e66af3a2377dad89971c9669a2 +dist/2026-11-10/clippy-beta-aarch64-apple-darwin.tar.xz=3357c87c2a8169c105a4cf541c861f95e6500e3473d6f442cd06b9c823ba4a6f +dist/2026-11-10/clippy-beta-aarch64-pc-windows-gnullvm.tar.gz=5987589ccef75ab54f8476183e8b111e2ca18459f1bcb308e1fd328ccc441a7b +dist/2026-11-10/clippy-beta-aarch64-pc-windows-gnullvm.tar.xz=e91a3c59bba5a7474a44107cc3cd49a3e12827542013ac2ba7e49bb37e216be6 +dist/2026-11-10/clippy-beta-aarch64-pc-windows-msvc.tar.gz=59d59696964f113671c6705f87a3171b3edb1e9dc124db5990a361889f99ceda +dist/2026-11-10/clippy-beta-aarch64-pc-windows-msvc.tar.xz=1e2b31a0c750e3375a681a798fd58da6ecc0933d42756e9ab772acbbca82efaf +dist/2026-11-10/clippy-beta-aarch64-unknown-freebsd.tar.gz=f30c3b174e85e8fb00731bcd3d602abdd8ca58ee73f8c16ba58837296ce13f16 +dist/2026-11-10/clippy-beta-aarch64-unknown-freebsd.tar.xz=d4406d78f79c1bc12ffccc882df5b832590cf198f55dc7322927e691c50c9a23 +dist/2026-11-10/clippy-beta-aarch64-unknown-linux-gnu.tar.gz=c880aa0f302dfe293acce564e7b2a6090e46b73331fde53bdb810b094380f188 +dist/2026-11-10/clippy-beta-aarch64-unknown-linux-gnu.tar.xz=ade7dad2c1f05f6911354ede7d466166424c2a25edf00bedb0a06a689f150d6b +dist/2026-11-10/clippy-beta-aarch64-unknown-linux-musl.tar.gz=15cc1fce73a7d7a274799b51cadf6221c0f350010af762dcbebcb03bfa957f07 +dist/2026-11-10/clippy-beta-aarch64-unknown-linux-musl.tar.xz=56c76b2260eabf56dfc33a7b39e671e7b829c4a6e2fbd73823cf39340538d77d +dist/2026-11-10/clippy-beta-aarch64-unknown-linux-ohos.tar.gz=d86595071bc6f91e533b0f7bedd867d486923696acc95ebf027b44f5ac13d69d +dist/2026-11-10/clippy-beta-aarch64-unknown-linux-ohos.tar.xz=d5eaee298d571c0800f1ca52799183f1d1aac3cbfb9aad78b33e604799da92fe +dist/2026-11-10/clippy-beta-arm-unknown-linux-gnueabi.tar.gz=dc8a8c4a96dd3317752306343d2315c454aaeb6f352d0fdb9f19ad893000d241 +dist/2026-11-10/clippy-beta-arm-unknown-linux-gnueabi.tar.xz=5db70f1c5d3cae9ed58912859e286dc55d1ae47e9442fac323a249270ec7c450 +dist/2026-11-10/clippy-beta-arm-unknown-linux-gnueabihf.tar.gz=9fca74b55f5cb930424f91f559198c3958c6eb2a4804290b34d4de170cb86774 +dist/2026-11-10/clippy-beta-arm-unknown-linux-gnueabihf.tar.xz=273206e08b57f79fc8e4669ac427d5c92c3147e0495982b6528d79d2e39a5d1d +dist/2026-11-10/clippy-beta-armv7-unknown-linux-gnueabihf.tar.gz=458ac55e971cc680474ddf26eaaf2894a3bb20a2c77d6be8d1074eb0c224d9fb +dist/2026-11-10/clippy-beta-armv7-unknown-linux-gnueabihf.tar.xz=f785e6dc91bf0bdb1be0bc9878560e7791f078abdff36fb0b6831318aebc0e74 +dist/2026-11-10/clippy-beta-i686-unknown-linux-gnu.tar.gz=ae61957b80cda5da800a22f033829b4332c096eefdd0c46c060892155432ce52 +dist/2026-11-10/clippy-beta-i686-unknown-linux-gnu.tar.xz=4bb532eead6865e82b2211eb97566a4b9637b98bd43e5db660abf6992ceedc81 +dist/2026-11-10/clippy-beta-loongarch64-unknown-linux-gnu.tar.gz=b2d1e62705d9d70dcf47317e4f8d979373635cfae50aa9c66cbefd38628dfa80 +dist/2026-11-10/clippy-beta-loongarch64-unknown-linux-gnu.tar.xz=af0c0ac92e570116495a36ee15a2c5ef094a4c8d4518ed1642805f410e85ec82 +dist/2026-11-10/clippy-beta-loongarch64-unknown-linux-musl.tar.gz=23b8609e46c5b10d71fcab49e56b4dc9bd80c21bbe4bc2c3a2f78eb29565ba7b +dist/2026-11-10/clippy-beta-loongarch64-unknown-linux-musl.tar.xz=844d75e064335acc753d1dc733765a434e77dda72efea0b89e80294263346a38 +dist/2026-11-10/clippy-beta-powerpc-unknown-linux-gnu.tar.gz=3e3a2b60a35030e4ea98d3823519825fbf2e948348bb2d1addce2376adf7443e +dist/2026-11-10/clippy-beta-powerpc-unknown-linux-gnu.tar.xz=f9b52587ee1d58398e179405ea35a76c47d6f13968be5b7c697a182116b7cf03 +dist/2026-11-10/clippy-beta-powerpc64-unknown-linux-gnu.tar.gz=74048a34170dad9f8adc3bb7b0e7b306c5984756f381f7264e333369d920967d +dist/2026-11-10/clippy-beta-powerpc64-unknown-linux-gnu.tar.xz=f52202ed699f91129d8941c09592f8bd6aa57d29114028c20125dff3f39361e0 +dist/2026-11-10/clippy-beta-powerpc64-unknown-linux-musl.tar.gz=068d0bfee136d79d7dddd0673329cac59876a144227e17f9bad60f041988b206 +dist/2026-11-10/clippy-beta-powerpc64-unknown-linux-musl.tar.xz=d59f431bfb11f7770d7a7f62ecf6a83cc78bbc5d52d0f70dbb3e01eddd62bc22 +dist/2026-11-10/clippy-beta-powerpc64le-unknown-linux-gnu.tar.gz=ddeda5a942698690809c1c4e48d808813d2fd3af0a636e3e938e83f7d7b512a4 +dist/2026-11-10/clippy-beta-powerpc64le-unknown-linux-gnu.tar.xz=ef440eb92cd58c9b4efabe1cae6edf909d8b8a752ce91bea2b5db3bc4afe261b +dist/2026-11-10/clippy-beta-powerpc64le-unknown-linux-musl.tar.gz=489b7a923938ec86db662f1c4916c574b00564994b5226ff03a2c1b6b1187dbe +dist/2026-11-10/clippy-beta-powerpc64le-unknown-linux-musl.tar.xz=53e7f8c1dd2a827e4892924b43bb105823c04bf8bd2511a5cce9440d9c7891eb +dist/2026-11-10/clippy-beta-riscv64gc-unknown-linux-gnu.tar.gz=6cadb4a6cd5c5907e98ea4bd4664be64beda78be55c2838db4d4b8ce779bac4b +dist/2026-11-10/clippy-beta-riscv64gc-unknown-linux-gnu.tar.xz=4b3e1c9ef70cd32e13a05381065b66c11e8706e518cc7464e9fccf3d534c5af5 +dist/2026-11-10/clippy-beta-riscv64gc-unknown-linux-musl.tar.gz=c41eff5da4de37ffa3abe99e22bb0a9b67b23465e8914e408df71e78ab03f94e +dist/2026-11-10/clippy-beta-riscv64gc-unknown-linux-musl.tar.xz=f50507d0927cd514414c010621dc54538c3332b1829f14b41bef074648bb3606 +dist/2026-11-10/clippy-beta-s390x-unknown-linux-gnu.tar.gz=19198068a388033d6d265f94c335206bc3993577a10f137136ec399a88b2e55e +dist/2026-11-10/clippy-beta-s390x-unknown-linux-gnu.tar.xz=478ef9c19dedd629c673c0dca108b36b0839954e01ce0652f3995daf3f369a76 +dist/2026-11-10/clippy-beta-sparcv9-sun-solaris.tar.gz=371b9711530d2d4e296bd2a1f45451068796b61cee51b3ef00a7c0d3e05aafc0 +dist/2026-11-10/clippy-beta-sparcv9-sun-solaris.tar.xz=88528cec2b69257923eca8fe16e09ed5867d3bb653ef3494c2e2aa56e722562f +dist/2026-11-10/clippy-beta-x86_64-apple-darwin.tar.gz=3b834e7a27f94a70bc29fead727637f7d4eb66cc8a05acf1014debfb51979d2e +dist/2026-11-10/clippy-beta-x86_64-apple-darwin.tar.xz=f83a9274a618eed949d0b6c1404aa6f05e28b5c10d746b2092fd9b85850669cd +dist/2026-11-10/clippy-beta-x86_64-pc-solaris.tar.gz=cc3802c5dbd4d4da561c00029d9b2b25114bc56b2d9e768f6421f63968683230 +dist/2026-11-10/clippy-beta-x86_64-pc-solaris.tar.xz=65ab569d4d71e704116dc4d0bf991f010b5f190bb7885956a5762e4b2513939f +dist/2026-11-10/clippy-beta-x86_64-pc-windows-gnu.tar.gz=c2f23132033660769c119f23434544782e81010539d20090187955da882abb9d +dist/2026-11-10/clippy-beta-x86_64-pc-windows-gnu.tar.xz=331fe21cac2970ab2f0aed56be19dbad0c1b078e4f61cc1057b589412b0fd8b0 +dist/2026-11-10/clippy-beta-x86_64-pc-windows-gnullvm.tar.gz=87710e533a1a94852073d8eb56264135080ef18b72e67d0b9605b3fd1ceb4798 +dist/2026-11-10/clippy-beta-x86_64-pc-windows-gnullvm.tar.xz=9d98528faa63e091a66de3c64781663896c45ad0cb552a398ba00e2735d27280 +dist/2026-11-10/clippy-beta-x86_64-pc-windows-msvc.tar.gz=5ad342690e002abc27a5824a5eb80b747781f6599fa5d76f674544540727489e +dist/2026-11-10/clippy-beta-x86_64-pc-windows-msvc.tar.xz=949da672b40ac81f0fa03ee4935f660d680ad1bd12ccaff3f832221378614f69 +dist/2026-11-10/clippy-beta-x86_64-unknown-freebsd.tar.gz=1d5ab313fcc5d253a5c7f28f7b973e16f87466935e6a3d328f8fcb3210c55d73 +dist/2026-11-10/clippy-beta-x86_64-unknown-freebsd.tar.xz=e75dc342971b3b25d71e2f55ccb64d718e718f3273aec31cbd50478dfddb8100 +dist/2026-11-10/clippy-beta-x86_64-unknown-illumos.tar.gz=c9749607c7ef766f718a50c2b820bb2264e60bfcff4ae394fb3aab77c91abad2 +dist/2026-11-10/clippy-beta-x86_64-unknown-illumos.tar.xz=48d9e00326a27416acdfbc0e23f70e21a98ad76b5f5c7071dc85dac3135e730c +dist/2026-11-10/clippy-beta-x86_64-unknown-linux-gnu.tar.gz=23cbd5a91536cb3b4cb1e6e26cd4260132fd0fe1152221eab1a822c4907aeb6f +dist/2026-11-10/clippy-beta-x86_64-unknown-linux-gnu.tar.xz=4591aa4cadbb78a27739cd29f49769b1a1d6bf18bed1e50eb2eec1a3e4392d88 +dist/2026-11-10/clippy-beta-x86_64-unknown-linux-musl.tar.gz=d5f5a3e0278766a7b55415eb0f752be997b9ca85cf206d0f2a630b4183921523 +dist/2026-11-10/clippy-beta-x86_64-unknown-linux-musl.tar.xz=df78d4b30bf360cb40aaa77a8f79bdb3a5b3ed78533740f192b8eb1670dc0b3a +dist/2026-11-10/clippy-beta-x86_64-unknown-netbsd.tar.gz=da4cd2edd354a0e2bec47aba683bb3bb300df6bbb87eeec4767b9686633cca08 +dist/2026-11-10/clippy-beta-x86_64-unknown-netbsd.tar.xz=dcbf198f869bc9ffb6c1f84545ef8080c5923a568a183839cd23c79002c368f3 +dist/2026-11-10/rust-beta-aarch64-pc-windows-gnullvm.msi=58b00ed4e6763294594fb1a013c0ba8c57376289c1c31e46b260ede6295e4eae +dist/2026-11-10/rust-beta-aarch64-pc-windows-msvc.msi=24d4b06bef0515d95418ab49dd2cc68a00e0a184b139567cf8970406f6a7d7b6 +dist/2026-11-10/rust-beta-x86_64-pc-windows-gnu.msi=1b189a4a9e9cdef9f0143dcfb90913a999a9faa9ad40d88bd12ee229576b45b7 +dist/2026-11-10/rust-beta-x86_64-pc-windows-gnullvm.msi=758893a9e02d528e50e2ab57497f3695815e4af0d4c85d90dcac785b1ef797c2 +dist/2026-11-10/rust-beta-x86_64-pc-windows-msvc.msi=1d900c820718f68a40e678a938f739eee88392fcb33032febb9e966adbeec28f +dist/2026-11-10/rust-beta-aarch64-apple-darwin.pkg=2367831cafba726a41f2ff3284eef87eac3eb0f880b9d40e455f368a1791251f +dist/2026-11-10/rust-beta-x86_64-apple-darwin.pkg=e3c8a83ca91d6e78ac30549836a08e8ddf159ff7e2e7639bb469b6897003f0d2 +dist/2026-11-10/rustc-beta-src.tar.gz=2541eabbbae7d161eb3351631700b7fb1c341150ac7e4eb68c12680b9a2b2beb +dist/2026-11-10/rustc-beta-src.tar.xz=c8b5a25f0d5f49dc18c93bfe157073953977adcf79d5cfc548221a5c345bd28c +dist/2026-11-10/rustfmt-nightly-aarch64-apple-darwin.tar.gz=683cf8801610fc9c9e89724f9eeb6d0f5efbeb89f71f68c85acb72d5b1b88af3 +dist/2026-11-10/rustfmt-nightly-aarch64-apple-darwin.tar.xz=454c068d1060ae6c8ce10e13f02b9672810b2d6bdbb550d59bcf1d956f01c5e2 +dist/2026-11-10/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.gz=732093afda253db8ddc6fa90fbc09559b868e8f39de57008f04901aa719089f8 +dist/2026-11-10/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.xz=cf873359143b84923572128c6eada139c77cffb84589a9f09291556ef73bf8f2 +dist/2026-11-10/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz=51a15004dc92857561a0ebef56877332c13d098799aea7151172cbd19e7ee472 +dist/2026-11-10/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz=5ee72b0bd5a0bb10aaff499a06f2539f0b406605b175909300236c96f082514e +dist/2026-11-10/rustfmt-nightly-aarch64-unknown-freebsd.tar.gz=2caa8af51ec0307a129d3f265ef3c82a7bac5b7b9fec2a9c9e536c3d64fc1e95 +dist/2026-11-10/rustfmt-nightly-aarch64-unknown-freebsd.tar.xz=3b9b7611ee76c1b600fbcc2ffa018a839b06076d53d93a7fca0c3d138a88b7fc +dist/2026-11-10/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz=8fed856c662acc1fc1c4555b841e2b01ad1653dbb1ed9ec3def5b56d4add045f +dist/2026-11-10/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz=a9cd276b40fc8f1b39c1d71da841f6256972a5b4afcbd12061946e1051adb54d +dist/2026-11-10/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz=b9616ab9d9a98156126ce097c055e01f784595f406dc2a2c97a69eb8a2cf559a +dist/2026-11-10/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz=8cd360051be311fec940ff99af5ed7f728a82aceb0312336de66146b6d35701d +dist/2026-11-10/rustfmt-nightly-aarch64-unknown-linux-ohos.tar.gz=cc8fea56b64ed4c3c06a9bf9c0936026c73f2d0c5836a33e32810a34d180295a +dist/2026-11-10/rustfmt-nightly-aarch64-unknown-linux-ohos.tar.xz=bbf008b69fabf087731c9fc06b7f4445820ff939d97bffad333adfdbf51769f1 +dist/2026-11-10/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz=2baa3a170da2b728bfaeb92c509d52e70a284075d88a022af3d9b14eb5d77d7f +dist/2026-11-10/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz=4cffe8b9578f7658d6a39e645532ff36315f9faf244a3bc4ae69289099662cd3 +dist/2026-11-10/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz=18824cc0aab62d94a5d0e2ea47cbd02f7b907cc5fd487b977dfe9493fa8ca71d +dist/2026-11-10/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz=fb0c17eb7e1b5b49c6469dbc4b1f4faba14b5e5e94cee45de8d3bb33988fd93a +dist/2026-11-10/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz=dd3fb8a30eb9e9a94261d0df3ee307e1b37ca4107a9e34dded6401f04df51b38 +dist/2026-11-10/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz=63b1037d098f8a70868a5ee7cb761d9e4285cbc01a3b9a9f27f8005e2f170464 +dist/2026-11-10/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz=0fbf94ebe81cc723040e1d39fa6796724ee3f2756962f74197546c2bd03dedfc +dist/2026-11-10/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz=499a0b6cae08ef4363d6e47766687e017184df22d664308fe51bdbf70e6ceb14 +dist/2026-11-10/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.gz=0cf5cce65b301623ea06673a1a58b7f2b183599bfbf7520fe38b7abe11f8916e +dist/2026-11-10/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.xz=2def5586bafb8a48231d48153d1e52b75fc294b68834fab8bd663f534a5ef2ef +dist/2026-11-10/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.gz=315ab85a2659b05350a1f2cbf604ab1ca1664b6314f7538ceaff36d53cf3b88d +dist/2026-11-10/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.xz=c8b43fcce52454b4297a2a663746474234c98d510cdac75561352c75ce84b500 +dist/2026-11-10/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz=ea5aed97cb888aad236ed6cd9eff7629381cb8d658175667ca5997143b95e924 +dist/2026-11-10/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz=aac5dd8ae03e2d64fd39cc7c729c3a8931a967db27c8d6832a5ab6ff0f84247e +dist/2026-11-10/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz=f901239d137739815b8b3fc008348e18297e02355d19ab7cf4d09fb840be8f26 +dist/2026-11-10/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz=a92e8c88de0e619bf608739f7059a1ea1756ee88fe8714f44ee2e4fb7ef218ff +dist/2026-11-10/rustfmt-nightly-powerpc64-unknown-linux-musl.tar.gz=a5d1676a9fbcab69fbcb221a23f7852a33921f9a703ece3e39757f421b9d9a6c +dist/2026-11-10/rustfmt-nightly-powerpc64-unknown-linux-musl.tar.xz=9bceda912d791a7b30fead81c61a9fd9a07892277a5d4f5f524d228839b07b94 +dist/2026-11-10/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz=37f8f3246bcec3a732c14b8bc381db0f31b50827965b11054bbc4272e6a169f7 +dist/2026-11-10/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz=2b5f76b68a2aeaa4c59838989f25ae954b1b89d9977c3acd1dd7bcfdcccaeb9f +dist/2026-11-10/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.gz=0660bf7cc8c3eec06e723c064bee619b4a4b20a860f843b6e29bcbc55f64ecf5 +dist/2026-11-10/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.xz=bb43e2427b350a2d643fd42d2142b2bc4006e58b962cdff9e5c2d969e1241ae6 +dist/2026-11-10/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz=36cea83a2014b76e98b3974a56f67842395992cd698cb94afd3d8c16b567fcfc +dist/2026-11-10/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz=9957113cc4d50b713b7d928c079a94850ed80c42483d6a75c922cb88a0312290 +dist/2026-11-10/rustfmt-nightly-riscv64gc-unknown-linux-musl.tar.gz=65ae49eb204104ac19a36772ca2792a201606549ff90287c0c62aa99b8d4d175 +dist/2026-11-10/rustfmt-nightly-riscv64gc-unknown-linux-musl.tar.xz=12860431d4d4ffa4eb7764ee93789e6ba9e8ec8ae444f8cda053d50182c3a87f +dist/2026-11-10/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz=73da23674accdd0eb7ef43d539497d40eec24e07068923e3ddb8a5418a1c7698 +dist/2026-11-10/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz=d1fb6ccb6841d9b93f0c83f096538b39cce64dcba9ce9e111e88ac64fa1134ef +dist/2026-11-10/rustfmt-nightly-sparcv9-sun-solaris.tar.gz=eb84b6d899ae5dacf8ce26f122016d24da65391aed00d876c32764589b4002d6 +dist/2026-11-10/rustfmt-nightly-sparcv9-sun-solaris.tar.xz=60716593022152f8953701c63a2caf6c982b6dbe040a8c18a3c5ec9620612b54 +dist/2026-11-10/rustfmt-nightly-x86_64-apple-darwin.tar.gz=3c99b23337154d26962b2b7b333ff9d2260f5f884697a6e97cf674fb2130f3f7 +dist/2026-11-10/rustfmt-nightly-x86_64-apple-darwin.tar.xz=d01c62e80ccdabc6852b0fc2e508601f1965176360b4a8c4beafde993d24e0d4 +dist/2026-11-10/rustfmt-nightly-x86_64-pc-solaris.tar.gz=ab0bfbf9f7fd2c3c2313be7e15a496130af04dfaf19ba4bd4586022aa372673f +dist/2026-11-10/rustfmt-nightly-x86_64-pc-solaris.tar.xz=3a8699662ad8841e2c8297131ca86bf08dcc64dd82dab1422ad867f655a564f2 +dist/2026-11-10/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz=e323b883978f00615dc1ba37897fc55b7f93692141c85502f5b8a7f9149bb66c +dist/2026-11-10/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz=f5ab77958ae9218a5b23aa922007ade7639baefac927158a7d25166df7b2d67e +dist/2026-11-10/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.gz=b86a6d01e2eefe9b72dd4e651c04786d68a7216a90d8448b8d8061cac6429585 +dist/2026-11-10/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.xz=268e11d308e607c80e8f4a3fbcb59a2d356f4e1be236c0b539dc09979cd641c4 +dist/2026-11-10/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz=a6e00e5602a2de947461eb77c1b34fb38080bef2df34986b0fe766e66ee71431 +dist/2026-11-10/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz=4faab06e5ab6af60634c26197611d375459e7e1e79903c221eb68a6d4ff14f93 +dist/2026-11-10/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz=b7b0b6334cf11389569830cd9fdb6b75fd2f3338fd2fd55a8192770da2d6c751 +dist/2026-11-10/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz=80642624a55244d319a8dacba5514a996d03ebddc375f797c7c9cddbf76cf918 +dist/2026-11-10/rustfmt-nightly-x86_64-unknown-illumos.tar.gz=7623dba6f2db5e904ff486c0adb1fdc02c4e0272f8f9566ee79b7c12541f9f6e +dist/2026-11-10/rustfmt-nightly-x86_64-unknown-illumos.tar.xz=c61f5f4700fe962534ea8a5004b8aa554d23d939686d8dc3567bcb6b80722488 +dist/2026-11-10/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz=dbf0768d8238a22ff053e54300a4f2c1ab84f9ce2ec33e0930356cfe564567c2 +dist/2026-11-10/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz=0847fec1618d44edf15c7f7e65c1fa1d082a9b8ecac7305e7a31b12ec4917874 +dist/2026-11-10/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz=e07fd9fba3cc7abda8b55c58fec5a8398b53a1bde66a7a2fda6e64ffc75184b3 +dist/2026-11-10/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz=a6a194edf422c50fa2655d4b524e9a4a063d732f2402a6badac0ba2ef13d28a2 +dist/2026-11-10/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz=9b60446358e711bf9633288488eb12cfc6c5e7f265ee5c2e0428b0434c825b4a +dist/2026-11-10/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz=9210eeb41a555bbdfe0b04f505a6eb965a6e5b4e2426e59acfc9b6b22ffbe0f6 +dist/2026-11-10/rustc-nightly-aarch64-apple-darwin.tar.gz=32b433a311765e77e3713d0580e5e81a4fedeea75899a0260a45526d36339bd8 +dist/2026-11-10/rustc-nightly-aarch64-apple-darwin.tar.xz=5153326af616f764902320950466abcc57362bf4e88be03005ba3abd39cb71e2 +dist/2026-11-10/rustc-nightly-aarch64-pc-windows-gnullvm.tar.gz=dbbf41f493ef2410099831069623d1242efca8883e89d311b54edc4974e054b7 +dist/2026-11-10/rustc-nightly-aarch64-pc-windows-gnullvm.tar.xz=fd5f7a381a35b35282784fd794929b552f9dd7dc96746bb4f55619f50b96e5b7 +dist/2026-11-10/rustc-nightly-aarch64-pc-windows-msvc.tar.gz=cb7ea316488d71b6003b2bcb0889b34727e45ce2540c5c3cfc6b7096b276bd9f +dist/2026-11-10/rustc-nightly-aarch64-pc-windows-msvc.tar.xz=3c72470ceb0858ffa4d9d6e23971ba30905b61ff4eae2f57fc9c296be4b719fa +dist/2026-11-10/rustc-nightly-aarch64-unknown-freebsd.tar.gz=bf3a94945eba58b42775b0dd944489573183de329703ce019daf4fbff1e36b0a +dist/2026-11-10/rustc-nightly-aarch64-unknown-freebsd.tar.xz=8c709411f239fa48dfd1872d061682133c325812dc456b280157e4507f560ef2 +dist/2026-11-10/rustc-nightly-aarch64-unknown-linux-gnu.tar.gz=ba38ad4479340017e0aa88fc86dee4ed9dd9c3be6133dc9500a9556c3d0e18af +dist/2026-11-10/rustc-nightly-aarch64-unknown-linux-gnu.tar.xz=3684589e77c60bba13fe9fff825aa2143d0a45d9375caa29f4153b6a195a3ee0 +dist/2026-11-10/rustc-nightly-aarch64-unknown-linux-musl.tar.gz=984089e58fd17c8f3de0b8e40729e8ca99f4ffc73846198e5deaa7b2f001f37d +dist/2026-11-10/rustc-nightly-aarch64-unknown-linux-musl.tar.xz=7eed69d93a8f8a065a70277e8c915dd961831036cb54804c53a798230c03fb23 +dist/2026-11-10/rustc-nightly-aarch64-unknown-linux-ohos.tar.gz=8734e1f02cfc1d5e85edad7443bb8f95b32a4cfd0fb932ea9b9d95c2e8610071 +dist/2026-11-10/rustc-nightly-aarch64-unknown-linux-ohos.tar.xz=a74e9f8c4c47d115872f973b357d26417c19455939e4cef2d195cd89f1532365 +dist/2026-11-10/rustc-nightly-arm-unknown-linux-gnueabi.tar.gz=baec8226e6b235a84b3c018d6bbee279fec2bae79c31429dd16865df551e9071 +dist/2026-11-10/rustc-nightly-arm-unknown-linux-gnueabi.tar.xz=491d76c9731aafc3b166b33802127123b5451d08f09a584a00c11131d9dcc1a9 +dist/2026-11-10/rustc-nightly-arm-unknown-linux-gnueabihf.tar.gz=90bc725b9cbc0860bd3cfef77248cdbbdef379e562fc20174ab6872e60851abb +dist/2026-11-10/rustc-nightly-arm-unknown-linux-gnueabihf.tar.xz=06b73d58d1c43c5d6553c16e818d39a8e72600e4a03cdf22a68848a7c0b5f779 +dist/2026-11-10/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.gz=4b10c6baf00f94a885a4c52df37f19f3b73905198afd65ef538268cd0e36e98a +dist/2026-11-10/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.xz=a179a633da7a733a8892e6ead34da261b55d6581d87d74819cc9090cb9211356 +dist/2026-11-10/rustc-nightly-i686-unknown-linux-gnu.tar.gz=77598c870d0430c7c81a31a2a627daad9c97af1fa5a77a85db0ec8df3a066b88 +dist/2026-11-10/rustc-nightly-i686-unknown-linux-gnu.tar.xz=ec9b37efe0d501e3ece2e15de467ff62e6ae7c0651a525f1dc5bc403e8b90650 +dist/2026-11-10/rustc-nightly-loongarch64-unknown-linux-gnu.tar.gz=e947aba1dfed5cd0107306f0d72e501fd96895a09db99f8015f3a366a2f51b28 +dist/2026-11-10/rustc-nightly-loongarch64-unknown-linux-gnu.tar.xz=a964be0c695217053dd9b8f7af699b7b60377c800ca2ada1f656d50b22ab2a77 +dist/2026-11-10/rustc-nightly-loongarch64-unknown-linux-musl.tar.gz=bbfbda3c53d7670b7d8be1759d818f4d1edc8ccb1a5a6197e6576735a0f50a20 +dist/2026-11-10/rustc-nightly-loongarch64-unknown-linux-musl.tar.xz=2888b5ad857c8c62a503e58082fe4cb1ee799e0950ecddc8c3582c0287fef84e +dist/2026-11-10/rustc-nightly-powerpc-unknown-linux-gnu.tar.gz=ee8e1fa9c9cfb870c2ddc398b584e2d0d12db4ea3012ada01aa65b30ec2ab0a5 +dist/2026-11-10/rustc-nightly-powerpc-unknown-linux-gnu.tar.xz=6b674c3499f696acb86eb5720c183e4ff8b04f3a3917e62e1a2ceb1a634bbe30 +dist/2026-11-10/rustc-nightly-powerpc64-unknown-linux-gnu.tar.gz=7f4c147db93cfbee189d8031e894b4ffdb528d5cccbcd75126b3e66b1cb96ff8 +dist/2026-11-10/rustc-nightly-powerpc64-unknown-linux-gnu.tar.xz=65385eec5f7c66397838b792bfb6ca87583d212e205c3cdadecf83b7b8ac73a3 +dist/2026-11-10/rustc-nightly-powerpc64-unknown-linux-musl.tar.gz=ee539dac6d21585bc015ff27a21183704c1c3602b3e8ab240c3cf5802fcec86e +dist/2026-11-10/rustc-nightly-powerpc64-unknown-linux-musl.tar.xz=017aa77171b3fd63d79aa8d78bb3c849b6a00dad1e20a319fb8847751c3004f9 +dist/2026-11-10/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.gz=416594fabd396dd7f50f7d88f84392b34e0e9cc741c49404e9dc2a77355e5dd6 +dist/2026-11-10/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.xz=51660dbf8558471fd26721b8306f2c7158596cdb27412e107685c39d69da4d9e +dist/2026-11-10/rustc-nightly-powerpc64le-unknown-linux-musl.tar.gz=11b5bc28e6c03a7f1735ca1590dd3831c072f9777f72ca88ca4f41a38643933d +dist/2026-11-10/rustc-nightly-powerpc64le-unknown-linux-musl.tar.xz=d798f109db52360fe6c62e1850cb78c16dc6c3dccce5171b89877de7c7bd00d2 +dist/2026-11-10/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.gz=d52e710ca5ba6a7f56252bb7ec101291f1fe7505de0fda0d41b891c9bb7ca571 +dist/2026-11-10/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.xz=19d13ce6434935d2b8704931356f6a1d59acae541015dba34bf7aab079d8d3b1 +dist/2026-11-10/rustc-nightly-riscv64gc-unknown-linux-musl.tar.gz=adf5db0fd5a2fbe6fa2b9d39d3c43481d05a3b877a2302542f45424c5b46eeca +dist/2026-11-10/rustc-nightly-riscv64gc-unknown-linux-musl.tar.xz=ce8862298e85a39bfb9077996ea0c9eae794c6a0fc8cf9c168d89c6698f8a7fb +dist/2026-11-10/rustc-nightly-s390x-unknown-linux-gnu.tar.gz=ba3241d5486c440c5974b706be2c4222b86382502b196cdd1bd727b79309ccae +dist/2026-11-10/rustc-nightly-s390x-unknown-linux-gnu.tar.xz=024bf30df3cece354b5d4a9ada5dc8a491395816aac8de8b30d5fcff8fc14b81 +dist/2026-11-10/rustc-nightly-sparcv9-sun-solaris.tar.gz=b07b4aa98b92d72a673bea4d5074c5b8314394c82426125da8c541328ed54a3e +dist/2026-11-10/rustc-nightly-sparcv9-sun-solaris.tar.xz=ee11acfbe456ad546c729f0b1f56d9da1e9010fb62f256f2d54cb8f52388537a +dist/2026-11-10/rustc-nightly-x86_64-apple-darwin.tar.gz=ef6773388591c95d60b484fb87a408786d1a91fe4727f6fffabc3f4f52ea771c +dist/2026-11-10/rustc-nightly-x86_64-apple-darwin.tar.xz=4d7776de4fbcd12d2e51a9a84e7d0d29c9cc545be28b5e9a2cede42a3578ed77 +dist/2026-11-10/rustc-nightly-x86_64-pc-solaris.tar.gz=16dfe299c5a27faa812fa1f1ee5fce372a8c99dea8c537baa1250cc9ef455b18 +dist/2026-11-10/rustc-nightly-x86_64-pc-solaris.tar.xz=101996f7fe5b2ca3b8adc6b404af9f6dab33794db725791e7d694de10c6c7b81 +dist/2026-11-10/rustc-nightly-x86_64-pc-windows-gnu.tar.gz=4ebf1dca70338102826f16680958244828d07c66515a5008a6fbf00ab54a90bd +dist/2026-11-10/rustc-nightly-x86_64-pc-windows-gnu.tar.xz=4e002a37464968cc8746dc16f80ffd7bb61c18bc0707c16dcf75d67bd00bf5f2 +dist/2026-11-10/rustc-nightly-x86_64-pc-windows-gnullvm.tar.gz=7535091ffc7d98bb815109be1f5274ef9ff5ea585bfec8191f763c5105617e49 +dist/2026-11-10/rustc-nightly-x86_64-pc-windows-gnullvm.tar.xz=cf09287352010b413e9b0fdb430feecc9e7e976cf4e88989d69293bad7e6d630 +dist/2026-11-10/rustc-nightly-x86_64-pc-windows-msvc.tar.gz=97aef1bfd2d78485b376512cbb35fd0f036200120d9e7814879050bbdaf8ef98 +dist/2026-11-10/rustc-nightly-x86_64-pc-windows-msvc.tar.xz=ed4c47758b660b956058098bd15d6ca19c8bb458f149f73a14dbf62f33a4b24b +dist/2026-11-10/rustc-nightly-x86_64-unknown-freebsd.tar.gz=85a4b9becc9a59ca2b4436733596313178c67264e4c9960431ce845bee3158b3 +dist/2026-11-10/rustc-nightly-x86_64-unknown-freebsd.tar.xz=abb2ecc31671bb0cf1a11e921d8e87b39e7fe7ae2de931f0b725c3c07c8d5434 +dist/2026-11-10/rustc-nightly-x86_64-unknown-illumos.tar.gz=e24c9cd688d7f3baa9c1bed2752b3e3c08f7aa62c93677649157cdd5d8f3cecc +dist/2026-11-10/rustc-nightly-x86_64-unknown-illumos.tar.xz=69ead8a46a6e2fad829b6f44674d116994f5edd3a803c4b693d19adcfdc4afc8 +dist/2026-11-10/rustc-nightly-x86_64-unknown-linux-gnu.tar.gz=825a79d7b9c1f45930c4e415b9100e440501726af5b90079595f1471e7e2af3f +dist/2026-11-10/rustc-nightly-x86_64-unknown-linux-gnu.tar.xz=4c34c8b44af403999f591758df471babc25b3996b546e82305fe882e9b31a3ee +dist/2026-11-10/rustc-nightly-x86_64-unknown-linux-musl.tar.gz=08005fc6075e3a023c635a76e8fb033125675fcea4690c361242483e2ca3aab4 +dist/2026-11-10/rustc-nightly-x86_64-unknown-linux-musl.tar.xz=f1d48d28cc66af73f43a11db59ea1f0cac99eef0cdba16849392f0dce81926ff +dist/2026-11-10/rustc-nightly-x86_64-unknown-netbsd.tar.gz=4fca590bb4c4788dcbbfd405430045d957e68ed025a2145f5a264e97ba38122b +dist/2026-11-10/rustc-nightly-x86_64-unknown-netbsd.tar.xz=f8420aa554b8660e7ccfbe47b56fbd11769946145f3299370d44c17e571bee7f +dist/2026-11-10/rust-nightly-aarch64-pc-windows-gnullvm.msi=785ba855a10a7fa41bf2654ac10a25e8e7f831dce24bc6eb58a46d2db62ede05 +dist/2026-11-10/rust-nightly-aarch64-pc-windows-msvc.msi=ccaa21d2443ceec3006d1894660f1858ff15610e810a9cb1317c8eee28072150 +dist/2026-11-10/rust-nightly-x86_64-pc-windows-gnu.msi=a49bf523e668f1c98cb6ca0a077e5b777e59d70796c3c81ffccf6764d59514d7 +dist/2026-11-10/rust-nightly-x86_64-pc-windows-gnullvm.msi=1721f42bebee2f3876e269a4aac1ecedd2a1ab21b30fa85162d7ff5af418367b +dist/2026-11-10/rust-nightly-x86_64-pc-windows-msvc.msi=b4de53c54bcc8a92773308568eb4782adef1c8d061d84aeb18cf1d5ae545f06b +dist/2026-11-10/rust-nightly-aarch64-apple-darwin.pkg=9d4111d1504354b8340568ed38d36e834e428fda845e7f288c43829dbefc6177 +dist/2026-11-10/rust-nightly-x86_64-apple-darwin.pkg=39451d1dab64700b323de82ec0d6bfd25a9638ae850f5c135fe91113f6a78c1e +dist/2026-11-10/rustc-nightly-src.tar.gz=fd73a029f7990e3bdd9c63c7d6b7df43cb5be039308812e2ee42ea9285697436 +dist/2026-11-10/rustc-nightly-src.tar.xz=8e2e233048bdc8677036b4a018fcc02c64fa0fbfe634f59b74e0cab16d846f5b diff --git a/src/tools/clippy/clippy_lints/src/lib.rs b/src/tools/clippy/clippy_lints/src/lib.rs index 49d15a5f15dc6..d537077c766f0 100644 --- a/src/tools/clippy/clippy_lints/src/lib.rs +++ b/src/tools/clippy/clippy_lints/src/lib.rs @@ -8,7 +8,6 @@ #![feature(iter_partition_in_place)] #![feature(macro_metavar_expr)] #![feature(macro_metavar_expr_concat)] -#![cfg_attr(bootstrap, feature(unwrap_infallible))] #![feature(rustc_private)] #![feature(stmt_expr_attributes)] #![recursion_limit = "512"] diff --git a/src/tools/clippy/clippy_utils/src/lib.rs b/src/tools/clippy/clippy_utils/src/lib.rs index eb5befb52c3e4..929666cd0ac89 100644 --- a/src/tools/clippy/clippy_utils/src/lib.rs +++ b/src/tools/clippy/clippy_utils/src/lib.rs @@ -1,4 +1,3 @@ -#![cfg_attr(bootstrap, feature(unwrap_infallible))] #![feature(deref_patterns)] #![feature(macro_metavar_expr)] #![feature(rustc_private)] diff --git a/src/tools/clippy/tests/ui/eager_transmute.fixed b/src/tools/clippy/tests/ui/eager_transmute.fixed index a62b4ff7c75e5..30e741755d9b4 100644 --- a/src/tools/clippy/tests/ui/eager_transmute.fixed +++ b/src/tools/clippy/tests/ui/eager_transmute.fixed @@ -1,4 +1,4 @@ -#![feature(rustc_attrs, pattern_types, pattern_type_macro)] +#![feature(rustc_attrs, pattern_types)] #![warn(clippy::eager_transmute)] #![expect(clippy::missing_transmute_annotations, clippy::transmute_int_to_non_zero)] diff --git a/src/tools/clippy/tests/ui/eager_transmute.rs b/src/tools/clippy/tests/ui/eager_transmute.rs index cc6fbc2ebd37d..c9f4c19d8837d 100644 --- a/src/tools/clippy/tests/ui/eager_transmute.rs +++ b/src/tools/clippy/tests/ui/eager_transmute.rs @@ -1,4 +1,4 @@ -#![feature(rustc_attrs, pattern_types, pattern_type_macro)] +#![feature(rustc_attrs, pattern_types)] #![warn(clippy::eager_transmute)] #![expect(clippy::missing_transmute_annotations, clippy::transmute_int_to_non_zero)] diff --git a/src/tools/miri/src/shims/files.rs b/src/tools/miri/src/shims/files.rs index b292565d449e8..4bf610143f670 100644 --- a/src/tools/miri/src/shims/files.rs +++ b/src/tools/miri/src/shims/files.rs @@ -568,8 +568,6 @@ impl FileDescription for FileHandle { #[derive(Debug)] pub struct DirHandle { pub(super) dir: Dir, - #[cfg(bootstrap)] - pub(super) fallback: std::path::PathBuf, } impl FileDescription for DirHandle { @@ -583,10 +581,7 @@ impl FileDescription for DirHandle { ) -> InterpResult<'tcx, Either, &'static str>> { assert!(communicate_allowed); - #[cfg(bootstrap)] - return interp_ok(Either::Left(self.dir.metadata())); - #[cfg(not(bootstrap))] - return interp_ok(Either::Left(self.dir.self_metadata())); + interp_ok(Either::Left(self.dir.self_metadata())) } fn read<'tcx>( diff --git a/src/tools/miri/src/shims/unix/fs.rs b/src/tools/miri/src/shims/unix/fs.rs index 5d7615b7473d3..383c505684e99 100644 --- a/src/tools/miri/src/shims/unix/fs.rs +++ b/src/tools/miri/src/shims/unix/fs.rs @@ -740,14 +740,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> { return ecx.set_errno_and_return_neg1_i32(LibcError("EISDIR")); } - let Some(fd) = ecx.machine.fds.insert_new(DirHandle { - dir, - #[cfg(bootstrap)] - fallback: match &dirfd { - Some(dirfd) => dirfd.fallback.join(&path).canonicalize().unwrap(), - None => path.canonicalize().unwrap(), - }, - }) else { + let Some(fd) = ecx.machine.fds.insert_new(DirHandle { dir }) else { return ecx.set_errno_and_return_neg1_i32(LibcError("EMFILE")); }; interp_ok(Scalar::from_i32(fd)) @@ -1413,20 +1406,12 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> { Ok(read_dir) => { // Create an underlying FD as well, in case someone calls `dirfd` later. // (We could do this lazily but that does not seem worth it.) - #[cfg(not(bootstrap))] - let dir = read_dir.dir(); - #[cfg(bootstrap)] - let dir = fs::Dir::open(&name); - let Ok(dir) = dir else { + let Ok(dir) = read_dir.dir() else { throw_unsup_format!( "cannot `opendir` this directory: failed to create directory handle" ); }; - let dir = this.machine.fds.new_ref(DirHandle { - dir, - #[cfg(bootstrap)] - fallback: name.canonicalize().unwrap(), - }); + let dir = this.machine.fds.new_ref(DirHandle { dir }); let dir_fd_id = dir.id(); let Some(dir_fd_num) = this.machine.fds.insert(dir) else { return this.set_errno_and_return_neg1_i32(LibcError("EMFILE")); @@ -2418,18 +2403,11 @@ impl FileMetadata { // (https://github.com/rust-lang/rust/issues/163032) let path = if cfg!(windows) && path.to_str() == Some(".") { Path::new("") } else { path }; - #[cfg(not(bootstrap))] let metadata = if symlink_nofollow_flag { dir.dir.symlink_metadata(path) } else { dir.dir.metadata(path) }; - #[cfg(bootstrap)] - let metadata = if symlink_nofollow_flag { - dir.fallback.join(path).symlink_metadata() - } else { - dir.fallback.join(path).metadata() - }; FileMetadata::from_host(ecx, metadata) } } diff --git a/src/tools/miri/src/shims/windows/fs.rs b/src/tools/miri/src/shims/windows/fs.rs index 650ef0147da7e..6a0c00a8d3515 100644 --- a/src/tools/miri/src/shims/windows/fs.rs +++ b/src/tools/miri/src/shims/windows/fs.rs @@ -302,11 +302,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> { unreachable!() } - let Some(fd_num) = ecx.machine.fds.insert_new(DirHandle { - dir, - #[cfg(bootstrap)] - fallback: file_name.canonicalize().unwrap(), - }) else { + let Some(fd_num) = ecx.machine.fds.insert_new(DirHandle { dir }) else { throw_unsup_format!("we ran out of FD numbers") }; interp_ok(Handle::File(fd_num)) diff --git a/src/tools/miri/tests/fail/validity/nonzero.rs b/src/tools/miri/tests/fail/validity/nonzero.rs index fba37ee170e3a..1e847c4792442 100644 --- a/src/tools/miri/tests/fail/validity/nonzero.rs +++ b/src/tools/miri/tests/fail/validity/nonzero.rs @@ -1,4 +1,4 @@ -#![feature(rustc_attrs, pattern_types, pattern_type_macro)] +#![feature(rustc_attrs, pattern_types)] #![allow(unused_attributes)] #[repr(transparent)] diff --git a/src/tools/miri/tests/pass/pattern-types.rs b/src/tools/miri/tests/pass/pattern-types.rs index 90fe0de546915..2422f79d25d88 100644 --- a/src/tools/miri/tests/pass/pattern-types.rs +++ b/src/tools/miri/tests/pass/pattern-types.rs @@ -1,4 +1,4 @@ -#![feature(pattern_types, pattern_type_macro, sized_hierarchy)] +#![feature(pattern_types, sized_hierarchy)] #![allow(dead_code)] use std::marker::PointeeSized; diff --git a/src/tools/run-make-support/src/external_deps/rustc.rs b/src/tools/run-make-support/src/external_deps/rustc.rs index fab7f2098ea1c..d023f29d2dce8 100644 --- a/src/tools/run-make-support/src/external_deps/rustc.rs +++ b/src/tools/run-make-support/src/external_deps/rustc.rs @@ -57,7 +57,7 @@ pub fn rustc_minicore() -> Rustc { let mut builder = rustc(); let minicore_path = source_root().join("tests/auxiliary/minicore.rs"); - builder.input(minicore_path).crate_name("minicore").crate_type("rlib"); + builder.input(minicore_path).crate_name("minicore").crate_type("rlib").edition("2024"); builder } diff --git a/tests/auxiliary/minicore.rs b/tests/auxiliary/minicore.rs index 737587c4d5403..aca69642057ab 100644 --- a/tests/auxiliary/minicore.rs +++ b/tests/auxiliary/minicore.rs @@ -24,11 +24,12 @@ lang_items, adt_const_params, auto_traits, + forced_keywords, freeze_impls, negative_impls, - pattern_types, rustc_attrs, decl_macro, + allow_internal_unstable, f16, f16b, cfg_target_has_reliable_f16b, @@ -522,12 +523,9 @@ pub enum c_void { __variant2, } -#[rustc_builtin_macro(pattern_type)] -#[macro_export] -macro_rules! pattern_type { - ($($arg:tt)*) => { - /* compiler built-in */ - }; +#[allow_internal_unstable(internal_syntax)] +pub macro pattern_type($($arg:tt)*) { + k#pattern_type($($arg)*) } #[lang = "Ordering"] diff --git a/tests/codegen-llvm/enum/enum-aggregate.rs b/tests/codegen-llvm/enum/enum-aggregate.rs index 46a1a03e96371..1e359480ad6a6 100644 --- a/tests/codegen-llvm/enum/enum-aggregate.rs +++ b/tests/codegen-llvm/enum/enum-aggregate.rs @@ -2,7 +2,7 @@ //@ only-64bit #![crate_type = "lib"] -#![feature(pattern_types, pattern_type_macro)] +#![feature(pattern_types)] use std::cmp::Ordering; use std::num::NonZero; diff --git a/tests/codegen-llvm/pattern_type_symbols.rs b/tests/codegen-llvm/pattern_type_symbols.rs index a90262ff12d21..f20940780d84d 100644 --- a/tests/codegen-llvm/pattern_type_symbols.rs +++ b/tests/codegen-llvm/pattern_type_symbols.rs @@ -4,11 +4,10 @@ //@ compile-flags: -Csymbol-mangling-version=v0 -Copt-level=0 --crate-type=lib #![feature(pattern_types)] -#![feature(pattern_type_macro)] use std::pat::pattern_type; -type NanoU32 = crate::pattern_type!(u32 is 0..=999_999_999); +type NanoU32 = pattern_type!(u32 is 0..=999_999_999); fn foo() {} diff --git a/tests/debuginfo/msvc-pretty-enums.rs b/tests/debuginfo/msvc-pretty-enums.rs index d418d8f0987e6..2ec127390ca75 100644 --- a/tests/debuginfo/msvc-pretty-enums.rs +++ b/tests/debuginfo/msvc-pretty-enums.rs @@ -232,7 +232,7 @@ //@ cdb-command: dx c_style_i128_d //@ cdb-check: c_style_i128_d : D [Type: enum2$] -#![feature(pattern_types, pattern_type_macro)] +#![feature(pattern_types)] use std::num::NonZero; @@ -271,9 +271,7 @@ enum NicheLayoutWithFields3 { } #[repr(transparent)] -struct Wrapping128( - std::pat::pattern_type!(i128 is -2..=1), -); +struct Wrapping128(std::pat::pattern_type!(i128 is -2..=1)); enum Wrapping128Niche { X(Wrapping128), diff --git a/tests/mir-opt/dataflow-const-prop/enum.rs b/tests/mir-opt/dataflow-const-prop/enum.rs index 80553a3974881..454e2849597f1 100644 --- a/tests/mir-opt/dataflow-const-prop/enum.rs +++ b/tests/mir-opt/dataflow-const-prop/enum.rs @@ -2,7 +2,7 @@ //@ compile-flags: -Zdump-mir-exclude-alloc-bytes // EMIT_MIR_FOR_EACH_BIT_WIDTH -#![feature(custom_mir, core_intrinsics, rustc_attrs, pattern_types, pattern_type_macro)] +#![feature(custom_mir, core_intrinsics, rustc_attrs, pattern_types)] use std::intrinsics::mir::*; diff --git a/tests/mir-opt/gvn.rs b/tests/mir-opt/gvn.rs index 2ce475f7401ac..366af8355c031 100644 --- a/tests/mir-opt/gvn.rs +++ b/tests/mir-opt/gvn.rs @@ -6,7 +6,7 @@ #![feature(rustc_attrs)] #![feature(custom_mir)] #![feature(core_intrinsics)] -#![feature(freeze, pattern_type_range_trait, const_trait_impl, pattern_types, pattern_type_macro)] +#![feature(freeze, pattern_type_range_trait, const_trait_impl, pattern_types)] #![allow(ambiguous_wide_pointer_comparisons)] #![allow(unconditional_panic)] #![allow(unnecessary_transmutes)] diff --git a/tests/mir-opt/jump_threading.rs b/tests/mir-opt/jump_threading.rs index ae56921bb1d44..cdf49fb36bef4 100644 --- a/tests/mir-opt/jump_threading.rs +++ b/tests/mir-opt/jump_threading.rs @@ -2,7 +2,7 @@ //@ compile-flags: -Zmir-enable-passes=+Inline // EMIT_MIR_FOR_EACH_PANIC_STRATEGY -#![feature(try_trait_v2, pattern_type_macro, pattern_types)] +#![feature(try_trait_v2, pattern_types)] #![feature(custom_mir, core_intrinsics, rustc_attrs)] use std::intrinsics::mir::*; diff --git a/tests/mir-opt/pattern_types.rs b/tests/mir-opt/pattern_types.rs index dfa4c40d2dd7b..c714060619c16 100644 --- a/tests/mir-opt/pattern_types.rs +++ b/tests/mir-opt/pattern_types.rs @@ -1,5 +1,4 @@ #![feature(pattern_types)] -#![feature(pattern_type_macro)] use std::pat::pattern_type; diff --git a/tests/pretty/offload/offload_kernel_nested.device.pp b/tests/pretty/offload/offload_kernel_nested.device.pp new file mode 100644 index 0000000000000..78ae27d5617b7 --- /dev/null +++ b/tests/pretty/offload/offload_kernel_nested.device.pp @@ -0,0 +1,25 @@ +#![feature(prelude_import)] +#![no_std] +//@ only-nightly +//@ revisions: host device + +//@ pretty-mode:expanded +//@ pretty-compare-only +//@[host] pp-exact:offload_kernel_nested.host.pp +//@[device] pp-exact:offload_kernel_nested.device.pp + +//@[device] compile-flags: -Zunstable-options -Zoffload=Device + +#![feature(gpu_offload)] +extern crate std; +#[prelude_import] +use ::std::prelude::rust_2015::*; + +use std::offload::offload_kernel; + +fn kernel() { + #[rustc_offload_kernel] + unsafe extern "gpu-kernel" fn inner_kernel() {} +} + +fn main() {} diff --git a/tests/pretty/offload/offload_kernel_nested.host.pp b/tests/pretty/offload/offload_kernel_nested.host.pp new file mode 100644 index 0000000000000..31e7556b9e28f --- /dev/null +++ b/tests/pretty/offload/offload_kernel_nested.host.pp @@ -0,0 +1,28 @@ +#![feature(prelude_import)] +#![no_std] +//@ only-nightly +//@ revisions: host device + +//@ pretty-mode:expanded +//@ pretty-compare-only +//@[host] pp-exact:offload_kernel_nested.host.pp +//@[device] pp-exact:offload_kernel_nested.device.pp + +//@[device] compile-flags: -Zunstable-options -Zoffload=Device + +#![feature(gpu_offload)] +extern crate std; +#[prelude_import] +use ::std::prelude::rust_2015::*; + +use std::offload::offload_kernel; + +fn kernel() { + #[rustc_offload_kernel] + #[inline(never)] + fn inner_kernel() { + + ::core::panicking::unimplemented_default_msg() + } +} +fn main() {} diff --git a/tests/pretty/offload/offload_kernel_nested.rs b/tests/pretty/offload/offload_kernel_nested.rs new file mode 100644 index 0000000000000..d50a90b34104a --- /dev/null +++ b/tests/pretty/offload/offload_kernel_nested.rs @@ -0,0 +1,20 @@ +//@ only-nightly +//@ revisions: host device + +//@ pretty-mode:expanded +//@ pretty-compare-only +//@[host] pp-exact:offload_kernel_nested.host.pp +//@[device] pp-exact:offload_kernel_nested.device.pp + +//@[device] compile-flags: -Zunstable-options -Zoffload=Device + +#![feature(gpu_offload)] + +use std::offload::offload_kernel; + +fn kernel() { + #[offload_kernel] + fn inner_kernel() {} +} + +fn main() {} diff --git a/tests/rustdoc-html/pattern-types-implementors.rs b/tests/rustdoc-html/pattern-types-implementors.rs index 2f49837b27e74..030b8b85f58dc 100644 --- a/tests/rustdoc-html/pattern-types-implementors.rs +++ b/tests/rustdoc-html/pattern-types-implementors.rs @@ -1,4 +1,4 @@ -#![feature(pattern_types, pattern_type_macro)] +#![feature(pattern_types)] #![crate_name = "pattern_types_implementors"] use std::pat::pattern_type; diff --git a/tests/ui-fulldeps/internal-lints/lint_pass_impl_without_macro.rs b/tests/ui-fulldeps/internal-lints/lint_pass_impl_without_macro.rs index 2e7e4f1f2d543..9bffe57a84639 100644 --- a/tests/ui-fulldeps/internal-lints/lint_pass_impl_without_macro.rs +++ b/tests/ui-fulldeps/internal-lints/lint_pass_impl_without_macro.rs @@ -1,6 +1,4 @@ //@ compile-flags: -Z unstable-options -// FIXME(bootstrap): Remove the ignore once we promote the next beta. -//@ ignore-stage1 #![feature(rustc_private)] #![feature(default_field_values)] diff --git a/tests/ui-fulldeps/internal-lints/lint_pass_impl_without_macro.stderr b/tests/ui-fulldeps/internal-lints/lint_pass_impl_without_macro.stderr index d9ffe034ddf3e..ba51d30cd5a3d 100644 --- a/tests/ui-fulldeps/internal-lints/lint_pass_impl_without_macro.stderr +++ b/tests/ui-fulldeps/internal-lints/lint_pass_impl_without_macro.stderr @@ -1,18 +1,18 @@ error: implementing `LintPass` by hand - --> $DIR/lint_pass_impl_without_macro.rs:22:6 + --> $DIR/lint_pass_impl_without_macro.rs:20:6 | LL | impl LintPass for Foo { | ^^^^^^^^ | = help: try using `declare_lint_pass!` or `impl_lint_pass!` instead note: the lint level is defined here - --> $DIR/lint_pass_impl_without_macro.rs:7:9 + --> $DIR/lint_pass_impl_without_macro.rs:5:9 | LL | #![deny(rustc::lint_pass_impl_without_macro)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: implementing `LintPass` by hand - --> $DIR/lint_pass_impl_without_macro.rs:36:14 + --> $DIR/lint_pass_impl_without_macro.rs:34:14 | LL | macro_rules! custom_lint_pass_macro { ... diff --git a/tests/ui-fulldeps/internal-lints/missing-generic-type-visitable-derive.rs b/tests/ui-fulldeps/internal-lints/missing-generic-type-visitable-derive.rs index d92cb12cf9a54..02c0a6ae5b370 100644 --- a/tests/ui-fulldeps/internal-lints/missing-generic-type-visitable-derive.rs +++ b/tests/ui-fulldeps/internal-lints/missing-generic-type-visitable-derive.rs @@ -1,6 +1,4 @@ //@ compile-flags: -Z unstable-options -// FIXME(bootstrap): Remove the ignore once we promote the next beta. -//@ ignore-stage1 #![crate_type = "lib"] #![feature(rustc_private)] diff --git a/tests/ui-fulldeps/internal-lints/missing-generic-type-visitable-derive.stderr b/tests/ui-fulldeps/internal-lints/missing-generic-type-visitable-derive.stderr index 94e1297adab27..91b6094f0a11a 100644 --- a/tests/ui-fulldeps/internal-lints/missing-generic-type-visitable-derive.stderr +++ b/tests/ui-fulldeps/internal-lints/missing-generic-type-visitable-derive.stderr @@ -1,5 +1,5 @@ error: missing `#[derive(GenericTypeVisitable)]` on a type which implements `TypeVisitable` - --> $DIR/missing-generic-type-visitable-derive.rs:20:1 + --> $DIR/missing-generic-type-visitable-derive.rs:18:1 | LL | struct DerivesRegular; | ^^^^^^^^^^^^^^^^^^^^^^ @@ -8,13 +8,13 @@ LL | struct DerivesRegular; = help: mark the type with `#[derive(GenericTypeVisitable)]` = help: or, if `GenericTypeVisitable` is derived, check whether all fields implement `GenericTypeVisitable` note: the lint level is defined here - --> $DIR/missing-generic-type-visitable-derive.rs:7:9 + --> $DIR/missing-generic-type-visitable-derive.rs:5:9 | LL | #![deny(rustc::missing_generic_type_visitable_derive)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: missing `#[derive(GenericTypeVisitable)]` on a type which implements `TypeVisitable` - --> $DIR/missing-generic-type-visitable-derive.rs:24:1 + --> $DIR/missing-generic-type-visitable-derive.rs:22:1 | LL | struct ImplsRegular; | ^^^^^^^^^^^^^^^^^^^^ @@ -23,7 +23,7 @@ LL | struct ImplsRegular; = help: or, if `GenericTypeVisitable` is derived, check whether all fields implement `GenericTypeVisitable` error: missing `#[derive(GenericTypeVisitable)]` on a type which implements `TypeVisitable` - --> $DIR/missing-generic-type-visitable-derive.rs:36:1 + --> $DIR/missing-generic-type-visitable-derive.rs:34:1 | LL | enum EnumDerivesRegular {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -32,7 +32,7 @@ LL | enum EnumDerivesRegular {} = help: or, if `GenericTypeVisitable` is derived, check whether all fields implement `GenericTypeVisitable` error: missing `#[derive(GenericTypeVisitable)]` on a type which implements `TypeVisitable` - --> $DIR/missing-generic-type-visitable-derive.rs:42:1 + --> $DIR/missing-generic-type-visitable-derive.rs:40:1 | LL | struct GenericOverIDerivesRegular(I::Clause); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -41,7 +41,7 @@ LL | struct GenericOverIDerivesRegular(I::Clause); = help: or, if `GenericTypeVisitable` is derived, check whether all fields implement `GenericTypeVisitable` error: missing `#[derive(GenericTypeVisitable)]` on a type which implements `TypeVisitable` - --> $DIR/missing-generic-type-visitable-derive.rs:55:1 + --> $DIR/missing-generic-type-visitable-derive.rs:53:1 | LL | struct GenericOverTDerivesRegular([T; 67]); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -50,7 +50,7 @@ LL | struct GenericOverTDerivesRegular([T; 67]); = help: or, if `GenericTypeVisitable` is derived, check whether all fields implement `GenericTypeVisitable` error: missing `#[derive(GenericTypeVisitable)]` on a type which implements `TypeVisitable` - --> $DIR/missing-generic-type-visitable-derive.rs:127:1 + --> $DIR/missing-generic-type-visitable-derive.rs:125:1 | LL | / struct FieldDoesntImplGeneric { LL | | diff --git a/tests/ui/checked-type-aliases/lint-explicit-outlives-requirements.fixed b/tests/ui/checked-type-aliases/lint-explicit-outlives-requirements.fixed new file mode 100644 index 0000000000000..8afe48b5ee3c3 --- /dev/null +++ b/tests/ui/checked-type-aliases/lint-explicit-outlives-requirements.fixed @@ -0,0 +1,14 @@ +// Test that lint `explicit_outlives_requirements` can also trigger on CTAs. + +//@ check-pass +//@ run-rustfix + +#![feature(checked_type_aliases)] +#![warn(explicit_outlives_requirements)] +#![allow(dead_code)] + +type A0<'a, T> = &'a T; //~ WARN [explicit_outlives_requirements] + +type A1<'a, T> = &'a T; //~ WARN [explicit_outlives_requirements] + +fn main() {} diff --git a/tests/ui/checked-type-aliases/lint-explicit-outlives-requirements.rs b/tests/ui/checked-type-aliases/lint-explicit-outlives-requirements.rs new file mode 100644 index 0000000000000..a12c31e8726d8 --- /dev/null +++ b/tests/ui/checked-type-aliases/lint-explicit-outlives-requirements.rs @@ -0,0 +1,14 @@ +// Test that lint `explicit_outlives_requirements` can also trigger on CTAs. + +//@ check-pass +//@ run-rustfix + +#![feature(checked_type_aliases)] +#![warn(explicit_outlives_requirements)] +#![allow(dead_code)] + +type A0<'a, T: 'a> = &'a T; //~ WARN [explicit_outlives_requirements] + +type A1<'a, T> = &'a T where T: 'a; //~ WARN [explicit_outlives_requirements] + +fn main() {} diff --git a/tests/ui/checked-type-aliases/lint-explicit-outlives-requirements.stderr b/tests/ui/checked-type-aliases/lint-explicit-outlives-requirements.stderr new file mode 100644 index 0000000000000..dabd9cf613afa --- /dev/null +++ b/tests/ui/checked-type-aliases/lint-explicit-outlives-requirements.stderr @@ -0,0 +1,20 @@ +warning: outlives requirements can be inferred + --> $DIR/lint-explicit-outlives-requirements.rs:10:14 + | +LL | type A0<'a, T: 'a> = &'a T; + | ^^^^ help: remove this bound + | +note: the lint level is defined here + --> $DIR/lint-explicit-outlives-requirements.rs:7:9 + | +LL | #![warn(explicit_outlives_requirements)] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +warning: outlives requirements can be inferred + --> $DIR/lint-explicit-outlives-requirements.rs:12:23 + | +LL | type A1<'a, T> = &'a T where T: 'a; + | ^^^^^^^^^^^^ help: remove this bound + +warning: 2 warnings emitted + diff --git a/tests/ui/const-generics/early/macro_rules-braces.stderr b/tests/ui/const-generics/early/macro_rules-braces.stderr index 6cc9a67f194b7..98e905d71c04b 100644 --- a/tests/ui/const-generics/early/macro_rules-braces.stderr +++ b/tests/ui/const-generics/early/macro_rules-braces.stderr @@ -2,7 +2,7 @@ error: expressions must be enclosed in braces to be used as const generic argume --> $DIR/macro_rules-braces.rs:44:17 | LL | let _: baz!(m::P); - | -----^^^^- this macro call doesn't expand to a type + | ^^^^ | help: enclose the `const` expression in braces | @@ -13,7 +13,7 @@ error: expressions must be enclosed in braces to be used as const generic argume --> $DIR/macro_rules-braces.rs:64:17 | LL | let _: baz!(10 + 7); - | -----^^^^^^- this macro call doesn't expand to a type + | ^^^^^^ | help: enclose the `const` expression in braces | diff --git a/tests/ui/const-generics/min_const_generics/macro-fail-const.stderr b/tests/ui/const-generics/min_const_generics/macro-fail-const.stderr index 2fa529c750d10..2688675f3aa43 100644 --- a/tests/ui/const-generics/min_const_generics/macro-fail-const.stderr +++ b/tests/ui/const-generics/min_const_generics/macro-fail-const.stderr @@ -2,10 +2,7 @@ error: expected type, found `{` --> $DIR/macro-fail-const.rs:16:27 | LL | fn make_marker() -> impl Marker { - | ---------------------- - | | - | this macro call doesn't expand to a type - | in this macro invocation + | ---------------------- in this macro invocation ... LL | macro_rules! gimme_a_const { LL | ($rusty: ident) => {{ let $rusty = 3; *&$rusty }} @@ -15,10 +12,7 @@ error: expected type, found `{` --> $DIR/macro-fail-const.rs:16:27 | LL | Example:: - | ---------------------- - | | - | this macro call doesn't expand to a type - | in this macro invocation + | ---------------------- in this macro invocation ... LL | macro_rules! gimme_a_const { LL | ($rusty: ident) => {{ let $rusty = 3; *&$rusty }} diff --git a/tests/ui/const-generics/min_const_generics/macro-fail.stderr b/tests/ui/const-generics/min_const_generics/macro-fail.stderr index 23eeec7f6daa0..c190ceb40a82d 100644 --- a/tests/ui/const-generics/min_const_generics/macro-fail.stderr +++ b/tests/ui/const-generics/min_const_generics/macro-fail.stderr @@ -2,10 +2,7 @@ error: expected type, found `{` --> $DIR/macro-fail.rs:27:27 | LL | fn make_marker() -> impl Marker { - | ---------------------- - | | - | this macro call doesn't expand to a type - | in this macro invocation + | ---------------------- in this macro invocation ... LL | macro_rules! gimme_a_const { LL | ($rusty: ident) => {{ let $rusty = 3; *&$rusty }} @@ -15,10 +12,7 @@ error: expected type, found `{` --> $DIR/macro-fail.rs:27:27 | LL | Example:: - | ---------------------- - | | - | this macro call doesn't expand to a type - | in this macro invocation + | ---------------------- in this macro invocation ... LL | macro_rules! gimme_a_const { LL | ($rusty: ident) => {{ let $rusty = 3; *&$rusty }} @@ -32,10 +26,7 @@ LL | () => {{ | ^ expected type ... LL | let _fail = Example::; - | ----------------- - | | - | this macro call doesn't expand to a type - | in this macro invocation + | ----------------- in this macro invocation error: unexpected end of macro invocation --> $DIR/macro-fail.rs:36:25 diff --git a/tests/ui/consts/const-eval/raw-bytes.rs b/tests/ui/consts/const-eval/raw-bytes.rs index c682a17b8decf..8d13b5513fb9f 100644 --- a/tests/ui/consts/const-eval/raw-bytes.rs +++ b/tests/ui/consts/const-eval/raw-bytes.rs @@ -4,7 +4,7 @@ // ignore-tidy-file-linelength #![allow(invalid_value, unnecessary_transmutes)] -#![feature(pattern_types, pattern_type_macro)] +#![feature(pattern_types)] #![feature(rustc_attrs, ptr_metadata, slice_from_ptr_range, const_slice_from_ptr_range)] use std::mem; diff --git a/tests/ui/consts/const-eval/ub-ref-ptr.rs b/tests/ui/consts/const-eval/ub-ref-ptr.rs index 9cd47e4b155e3..eadb7ccf1126c 100644 --- a/tests/ui/consts/const-eval/ub-ref-ptr.rs +++ b/tests/ui/consts/const-eval/ub-ref-ptr.rs @@ -6,7 +6,7 @@ //@ normalize-stderr: "0x[0-9](\.\.|\])" -> "0x%$1" //@ normalize-stderr: "╾ALLOC\$ID╼\s+│.*╾.*╼" -> "╾ALLOC$$ID╼ │ ╾─╼" -#![feature(pattern_types, pattern_type_macro)] +#![feature(pattern_types)] #![allow(invalid_value)] use std::{mem, pat::pattern_type}; diff --git a/tests/ui/derives/debug/nonsense-input-to-debug.stderr b/tests/ui/derives/debug/nonsense-input-to-debug.stderr index 207d7b1969de5..ee35d5e624856 100644 --- a/tests/ui/derives/debug/nonsense-input-to-debug.stderr +++ b/tests/ui/derives/debug/nonsense-input-to-debug.stderr @@ -12,7 +12,6 @@ LL | should_be_vec_t: vec![T], | | | expected type | in this macro invocation - | this macro call doesn't expand to a type error[E0392]: type parameter `T` is never used --> $DIR/nonsense-input-to-debug.rs:5:17 diff --git a/tests/ui/enum-discriminant/ptr_niche.rs b/tests/ui/enum-discriminant/ptr_niche.rs index 45dbe50248217..4390b69de0516 100644 --- a/tests/ui/enum-discriminant/ptr_niche.rs +++ b/tests/ui/enum-discriminant/ptr_niche.rs @@ -2,7 +2,7 @@ //! Check that we can codegen setting and getting discriminants, including non-null niches, //! for enums with a pointer-like ABI. This used to crash llvm. -#![feature(rustc_attrs, pattern_types, pattern_type_macro)] +#![feature(rustc_attrs, pattern_types)] use std::{ptr, mem, pat::pattern_type}; #[derive(Copy, Clone)] diff --git a/tests/ui/field_representing_types/invalid.next.stderr b/tests/ui/field_representing_types/invalid.next.stderr index 82b2aa81451ab..3d6775fe8b376 100644 --- a/tests/ui/field_representing_types/invalid.next.stderr +++ b/tests/ui/field_representing_types/invalid.next.stderr @@ -37,10 +37,7 @@ error: `field_of` expects dot-separated field and variant names --> $DIR/invalid.rs:28:12 | LL | let _: field_of!(Enum, Variant..field); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - | | - | in this macro invocation - | this macro call doesn't expand to a type + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ in this macro invocation error: offset_of expects dot-separated field and variant names --> $DIR/invalid.rs:30:30 @@ -52,19 +49,13 @@ error: `field_of` expects dot-separated field and variant names --> $DIR/invalid.rs:30:12 | LL | let _: field_of!(Struct, [42]); - | ^^^^^^^^^^^^^^^^^^^^^^^ - | | - | in this macro invocation - | this macro call doesn't expand to a type + | ^^^^^^^^^^^^^^^^^^^^^^^ in this macro invocation error: `field_of` only supports a single field or a variant with a field --> $DIR/invalid.rs:32:30 | LL | let _: field_of!(Struct, field1.field2.field3); - | ------------------^^^^^^-^^^^^^-^^^^^^- - | | - | in this macro invocation - | this macro call doesn't expand to a type + | ------------------^^^^^^-^^^^^^-^^^^^^- in this macro invocation error: aborting due to 8 previous errors diff --git a/tests/ui/field_representing_types/invalid.old.stderr b/tests/ui/field_representing_types/invalid.old.stderr index 82b2aa81451ab..3d6775fe8b376 100644 --- a/tests/ui/field_representing_types/invalid.old.stderr +++ b/tests/ui/field_representing_types/invalid.old.stderr @@ -37,10 +37,7 @@ error: `field_of` expects dot-separated field and variant names --> $DIR/invalid.rs:28:12 | LL | let _: field_of!(Enum, Variant..field); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - | | - | in this macro invocation - | this macro call doesn't expand to a type + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ in this macro invocation error: offset_of expects dot-separated field and variant names --> $DIR/invalid.rs:30:30 @@ -52,19 +49,13 @@ error: `field_of` expects dot-separated field and variant names --> $DIR/invalid.rs:30:12 | LL | let _: field_of!(Struct, [42]); - | ^^^^^^^^^^^^^^^^^^^^^^^ - | | - | in this macro invocation - | this macro call doesn't expand to a type + | ^^^^^^^^^^^^^^^^^^^^^^^ in this macro invocation error: `field_of` only supports a single field or a variant with a field --> $DIR/invalid.rs:32:30 | LL | let _: field_of!(Struct, field1.field2.field3); - | ------------------^^^^^^-^^^^^^-^^^^^^- - | | - | in this macro invocation - | this macro call doesn't expand to a type + | ------------------^^^^^^-^^^^^^-^^^^^^- in this macro invocation error: aborting due to 8 previous errors diff --git a/tests/ui/fn/fn-ptr-trait-run.rs b/tests/ui/fn/fn-ptr-trait-run.rs index 529deb9be1e0a..e90bb019dca22 100644 --- a/tests/ui/fn/fn-ptr-trait-run.rs +++ b/tests/ui/fn/fn-ptr-trait-run.rs @@ -1,7 +1,7 @@ #![feature(fn_static)] //@ run-pass -use std::ops::FnPtr; +use std::ops::{FnPtr, FnAddr}; fn bar(a: u64) -> u64 { a @@ -11,5 +11,6 @@ fn main() { type F = fn(u64) -> u64; let b: F = bar; assert_eq!(b.addr(), bar as *const () as usize); + assert_eq!(b.addr(), bar.addr()); assert_eq!(b(42), unsafe { F::from_ptr(b.as_ptr())(42) }); } diff --git a/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/try-from-error-debug-bound-81162.rs b/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/try-from-error-debug-bound-81162.rs new file mode 100644 index 0000000000000..b5a233672f594 --- /dev/null +++ b/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/try-from-error-debug-bound-81162.rs @@ -0,0 +1,17 @@ +//! Regression test for . +//@ check-pass + +use std::convert::TryFrom; +use std::fmt::Debug; + +fn read() -> Vec +where + for<'a> T: TryFrom<&'a [f32]>, + for<'a> >::Error: Debug, +{ + Vec::new() +} + +fn main() { + let _ = read::<[f32; 128]>(); +} diff --git a/tests/ui/lint/clashing-extern-fn.rs b/tests/ui/lint/clashing-extern-fn.rs index e4477c9620221..195aab24899cf 100644 --- a/tests/ui/lint/clashing-extern-fn.rs +++ b/tests/ui/lint/clashing-extern-fn.rs @@ -1,7 +1,7 @@ //@ check-pass //@ aux-build:external_extern_fn.rs #![crate_type = "lib"] -#![feature(pattern_type_macro, pattern_types)] +#![feature(pattern_types)] mod redeclared_different_signature { mod a { extern "C" { diff --git a/tests/ui/lint/invalid_value.rs b/tests/ui/lint/invalid_value.rs index 301283853eb26..f76d988f44c68 100644 --- a/tests/ui/lint/invalid_value.rs +++ b/tests/ui/lint/invalid_value.rs @@ -2,7 +2,7 @@ // in a lint. #![allow(deprecated)] #![deny(invalid_value)] -#![feature(rustc_attrs, pattern_types, pattern_type_macro)] +#![feature(rustc_attrs, pattern_types)] use std::mem::{self, MaybeUninit}; use std::num::NonZero; diff --git a/tests/ui/lint/rfc-2383-lint-reason/derive-expect-issue-150553.rs b/tests/ui/lint/rfc-2383-lint-reason/derive-expect-issue-150553.rs index 06ec71bb6c84d..4c09b40344c0f 100644 --- a/tests/ui/lint/rfc-2383-lint-reason/derive-expect-issue-150553.rs +++ b/tests/ui/lint/rfc-2383-lint-reason/derive-expect-issue-150553.rs @@ -1,11 +1,9 @@ -// FIXME: Bring back duplication of the `#[expect]` attribute when deriving. -// -// Make sure we properly copy the `#[expect]` attr to the derived code and that no -// unfulfilled expectations are trigerred. +// Make sure `#[expect]` on an item with a derive is fulfilled when the lint is only emitted on the +// item itself, and not also on the derived impl, which reuses the lifetime spans of the input. // // See for rational. -//@ check-fail +//@ check-pass #![deny(redundant_lifetimes)] @@ -14,7 +12,6 @@ use std::fmt::Debug; #[derive(Debug)] #[expect(redundant_lifetimes)] pub struct RefWrapper<'a, T> -//~^ ERROR redundant_lifetimes where 'a: 'static, T: Debug, diff --git a/tests/ui/lint/rfc-2383-lint-reason/derive-expect-issue-150553.stderr b/tests/ui/lint/rfc-2383-lint-reason/derive-expect-issue-150553.stderr deleted file mode 100644 index c4047329d5c1f..0000000000000 --- a/tests/ui/lint/rfc-2383-lint-reason/derive-expect-issue-150553.stderr +++ /dev/null @@ -1,15 +0,0 @@ -error: unnecessary lifetime parameter `'a` - --> $DIR/derive-expect-issue-150553.rs:16:23 - | -LL | pub struct RefWrapper<'a, T> - | ^^ - | - = note: you can use the `'static` lifetime directly, in place of `'a` -note: the lint level is defined here - --> $DIR/derive-expect-issue-150553.rs:10:9 - | -LL | #![deny(redundant_lifetimes)] - | ^^^^^^^^^^^^^^^^^^^ - -error: aborting due to 1 previous error - diff --git a/tests/ui/macros/macro-interpolation.stderr b/tests/ui/macros/macro-interpolation.stderr index 3dc6ef6132d2a..304e7311e2d4e 100644 --- a/tests/ui/macros/macro-interpolation.stderr +++ b/tests/ui/macros/macro-interpolation.stderr @@ -7,10 +7,7 @@ LL | <$type as $trait>::$name | ^^^^^^ expected identifier, found metavariable ... LL | let _: qpath!(ty, ::Owned); - | ----------------------------- - | | - | this macro call doesn't expand to a type - | in this macro invocation + | ----------------------------- in this macro invocation error: aborting due to 1 previous error diff --git a/tests/ui/mir/ssa-analysis-regression-50041.rs b/tests/ui/mir/ssa-analysis-regression-50041.rs index 28690624f63ec..37d78acc2c452 100644 --- a/tests/ui/mir/ssa-analysis-regression-50041.rs +++ b/tests/ui/mir/ssa-analysis-regression-50041.rs @@ -2,7 +2,7 @@ //@ compile-flags: -Z mir-opt-level=4 #![crate_type = "lib"] -#![feature(lang_items, pattern_type_macro, pattern_types)] +#![feature(lang_items, pattern_types)] #![no_std] struct NonNull(pattern_type!(*const T is !null)); diff --git a/tests/ui/offload/offload_kernel_illegal.rs b/tests/ui/offload/offload_kernel_illegal.rs new file mode 100644 index 0000000000000..ce3d14b9d906f --- /dev/null +++ b/tests/ui/offload/offload_kernel_illegal.rs @@ -0,0 +1,21 @@ +#![feature(gpu_offload)] + +fn dummy() { + #[core::offload::offload_kernel] + //~^ ERROR macro attributes on statements are unstable + let mut x = 5; + //~^ ERROR offload_kernel must be applied to function + + #[core::offload::offload_kernel] + x = x + 3; + //~^^ ERROR attributes on expressions are experimental [E0658] + //~| ERROR macro attributes on expressions are unstable + //~^^^ ERROR offload_kernel must be applied to function + + #[core::offload::offload_kernel] + //~^ ERROR macro attributes on statements are unstable + let add_one_v2 = |x: u32| -> u32 { x + 1 }; + //~^ ERROR offload_kernel must be applied to function +} + +fn main() {} diff --git a/tests/ui/offload/offload_kernel_illegal.stderr b/tests/ui/offload/offload_kernel_illegal.stderr new file mode 100644 index 0000000000000..d41e01d54d17f --- /dev/null +++ b/tests/ui/offload/offload_kernel_illegal.stderr @@ -0,0 +1,61 @@ +error[E0658]: attributes on expressions are experimental + --> $DIR/offload_kernel_illegal.rs:9:5 + | +LL | #[core::offload::offload_kernel] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: see issue #15701 for more information + = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable + = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date + +error[E0658]: macro attributes on statements are unstable + --> $DIR/offload_kernel_illegal.rs:4:5 + | +LL | #[core::offload::offload_kernel] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: see issue #54727 for more information + = help: add `#![feature(proc_macro_hygiene)]` to the crate attributes to enable + = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date + +error: offload_kernel must be applied to function + --> $DIR/offload_kernel_illegal.rs:6:5 + | +LL | let mut x = 5; + | ^^^^^^^^^^^^^^ + +error[E0658]: macro attributes on expressions are unstable + --> $DIR/offload_kernel_illegal.rs:9:5 + | +LL | #[core::offload::offload_kernel] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: see issue #54727 for more information + = help: add `#![feature(proc_macro_hygiene)]` to the crate attributes to enable + = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date + +error: offload_kernel must be applied to function + --> $DIR/offload_kernel_illegal.rs:10:5 + | +LL | x = x + 3; + | ^ + +error[E0658]: macro attributes on statements are unstable + --> $DIR/offload_kernel_illegal.rs:15:5 + | +LL | #[core::offload::offload_kernel] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: see issue #54727 for more information + = help: add `#![feature(proc_macro_hygiene)]` to the crate attributes to enable + = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date + +error: offload_kernel must be applied to function + --> $DIR/offload_kernel_illegal.rs:17:5 + | +LL | let add_one_v2 = |x: u32| -> u32 { x + 1 }; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 7 previous errors + +For more information about this error, try `rustc --explain E0658`. diff --git a/tests/ui/pattern/overflowing-literals.rs b/tests/ui/pattern/overflowing-literals.rs index 13016d3f7d197..9e33d49963ee0 100644 --- a/tests/ui/pattern/overflowing-literals.rs +++ b/tests/ui/pattern/overflowing-literals.rs @@ -1,7 +1,6 @@ //! Check that overflowing literals are in patterns are rejected #![feature(pattern_types)] -#![feature(pattern_type_macro)] use std::pat::pattern_type; diff --git a/tests/ui/pattern/overflowing-literals.stderr b/tests/ui/pattern/overflowing-literals.stderr index 8164b97fd4720..54525cf6cd9f8 100644 --- a/tests/ui/pattern/overflowing-literals.stderr +++ b/tests/ui/pattern/overflowing-literals.stderr @@ -1,5 +1,5 @@ error: literal out of range for `u8` - --> $DIR/overflowing-literals.rs:8:35 + --> $DIR/overflowing-literals.rs:7:35 | LL | type TooBig = pattern_type!(u8 is 500..); | ^^^ @@ -8,7 +8,7 @@ LL | type TooBig = pattern_type!(u8 is 500..); = note: `#[deny(overflowing_literals)]` on by default error: literal out of range for `i8` - --> $DIR/overflowing-literals.rs:10:37 + --> $DIR/overflowing-literals.rs:9:37 | LL | type TooSmall = pattern_type!(i8 is -500..); | ^^^^ @@ -17,7 +17,7 @@ LL | type TooSmall = pattern_type!(i8 is -500..); = help: consider using the type `i16` instead error: literal out of range for `i8` - --> $DIR/overflowing-literals.rs:12:41 + --> $DIR/overflowing-literals.rs:11:41 | LL | type TooBigSigned = pattern_type!(i8 is 200..); | ^^^ @@ -26,7 +26,7 @@ LL | type TooBigSigned = pattern_type!(i8 is 200..); = help: consider using the type `u8` instead error: literal out of range for `u8` - --> $DIR/overflowing-literals.rs:17:9 + --> $DIR/overflowing-literals.rs:16:9 | LL | 500 => {} | ^^^ diff --git a/tests/ui/print_type_sizes/niche-filling.rs b/tests/ui/print_type_sizes/niche-filling.rs index 2fcb1dfe3c8c2..ecd243cd01ba8 100644 --- a/tests/ui/print_type_sizes/niche-filling.rs +++ b/tests/ui/print_type_sizes/niche-filling.rs @@ -15,7 +15,7 @@ // ^-- needed because `--pass check` does not emit the output needed. // FIXME: consider using an attribute instead of side-effects. #![allow(dead_code)] -#![feature(rustc_attrs, pattern_types, pattern_type_macro)] +#![feature(rustc_attrs, pattern_types)] use std::num::NonZero; diff --git a/tests/ui/proc-macro/lifetimes.stderr b/tests/ui/proc-macro/lifetimes.stderr index 315b4c5917243..aa5ef8559ced3 100644 --- a/tests/ui/proc-macro/lifetimes.stderr +++ b/tests/ui/proc-macro/lifetimes.stderr @@ -2,10 +2,7 @@ error: expected type, found `'` --> $DIR/lifetimes.rs:7:10 | LL | type A = single_quote_alone!(); - | ^^^^^^^^^^^^^^^^^^^^^ - | | - | expected type - | this macro call doesn't expand to a type + | ^^^^^^^^^^^^^^^^^^^^^ expected type | = note: this error originates in the macro `single_quote_alone` (in Nightly builds, run with -Z macro-backtrace for more info) diff --git a/tests/ui/recursion/infinite-dereference-recursion-issue-67064.rs b/tests/ui/recursion/infinite-dereference-recursion-issue-67064.rs new file mode 100644 index 0000000000000..17c758d817e3a --- /dev/null +++ b/tests/ui/recursion/infinite-dereference-recursion-issue-67064.rs @@ -0,0 +1,18 @@ +//@ compile-flags: -Zwrite-long-types-to-disk=yes + +// Regression test for: https://github.com/rust-lang/rust/issues/67064 +// This used to take a long time to compile because dereferencing led to +// recursive expansion of the type of the struct. + +struct S(T); + +impl std::ops::Deref for S { + type Target = S<(T, T)>; + fn deref(&self) -> &Self::Target { + self.thing() + //~^ ERROR: reached the recursion limit while auto-dereferencing + //~| ERROR: no method named `thing` found for reference + } +} + +fn main() {} diff --git a/tests/ui/recursion/infinite-dereference-recursion-issue-67064.stderr b/tests/ui/recursion/infinite-dereference-recursion-issue-67064.stderr new file mode 100644 index 0000000000000..4b3419b3a3e72 --- /dev/null +++ b/tests/ui/recursion/infinite-dereference-recursion-issue-67064.stderr @@ -0,0 +1,20 @@ +error[E0055]: reached the recursion limit while auto-dereferencing `S<(((((((((((((_, _), _), _), _), _), _), _), _), _), _), _), _), _)>` + --> $DIR/infinite-dereference-recursion-issue-67064.rs:12:14 + | +LL | self.thing() + | ^^^^^ deref recursion limit reached + | + = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`infinite_dereference_recursion_issue_67064`) + = note: the full name for the type has been written to '$TEST_BUILD_DIR/infinite-dereference-recursion-issue-67064.long-type-$LONG_TYPE_HASH.txt' + = note: consider using `--verbose` to print the full type name to the console + +error[E0599]: no method named `thing` found for reference `&S` in the current scope + --> $DIR/infinite-dereference-recursion-issue-67064.rs:12:14 + | +LL | self.thing() + | ^^^^^ method not found in `&S` + +error: aborting due to 2 previous errors + +Some errors have detailed explanations: E0055, E0599. +For more information about an error, try `rustc --explain E0055`. diff --git a/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-macro.fixed b/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-macro.fixed index 435857224ac31..1ed17ed4061e9 100644 --- a/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-macro.fixed +++ b/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-macro.fixed @@ -40,7 +40,7 @@ mod everything_inside { ('b: 'a) => { struct Foo<'a, 'b>(&'a &'b ()); //~^ ERROR: outlives requirements can be inferred - struct Bar<'a, 'b>(&'a &'b ()) ; + struct Bar<'a, 'b>(&'a &'b ()); //~^ ERROR: outlives requirements can be inferred struct Baz<'a, 'b>(&'a &'b ()) where (): Sized, ; //~^ ERROR: outlives requirements can be inferred @@ -54,7 +54,7 @@ mod inner_lifetime_outside_colon_inside { ($b:lifetime: 'a) => { struct Foo<'a, $b>(&'a &$b ()); //~^ ERROR: outlives requirements can be inferred - struct Bar<'a, $b>(&'a &$b ()) ; + struct Bar<'a, $b>(&'a &$b ()); //~^ ERROR: outlives requirements can be inferred struct Baz<'a, $b>(&'a &$b ()) where (): Sized, ; //~^ ERROR: outlives requirements can be inferred @@ -114,7 +114,7 @@ mod everything_outside_with_tt_outer { // FIXME: replacement span is corrupted due to a collision in metavar span table. // struct Foo<$a, $b $colon $a>(&$a &$b ()); // ^ ERROR: outlives requirements can be inferred - struct Bar<$a, $b>(&$a &$b ()) ; + struct Bar<$a, $b>(&$a &$b ()); //~^ ERROR: outlives requirements can be inferred struct Baz<$a, $b>(&$a &$b ()) where (): Sized, ; //~^ ERROR: outlives requirements can be inferred @@ -129,7 +129,7 @@ mod everything_outside_with_tt_both { // FIXME: replacement span is corrupted due to a collision in metavar span table. // struct Foo<$a, $b $colon $a>(&$a &$b ()); // ^ ERROR: outlives requirements can be inferred - struct Bar<$a, $b>(&$a &$b ()) ; + struct Bar<$a, $b>(&$a &$b ()); //~^ ERROR: outlives requirements can be inferred struct Baz<$a, $b>(&$a &$b ()) where (): Sized, ; //~^ ERROR: outlives requirements can be inferred diff --git a/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-macro.stderr b/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-macro.stderr index cda31ed346f28..55f462098b24f 100644 --- a/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-macro.stderr +++ b/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-macro.stderr @@ -28,12 +28,12 @@ LL | m!('b: 'a); | ---------- in this macro invocation error: outlives requirements can be inferred - --> $DIR/edition-lint-infer-outlives-macro.rs:43:44 + --> $DIR/edition-lint-infer-outlives-macro.rs:43:43 | LL | macro_rules! m { ... LL | struct Bar<'a, 'b>(&'a &'b ()) where 'b: 'a; - | ^^^^^^^^^^^^ help: remove this bound + | ^^^^^^^^^^^^^ help: remove this bound ... LL | m!('b: 'a); | ---------- in this macro invocation @@ -61,12 +61,12 @@ LL | m!('b: 'a); | ---------- in this macro invocation error: outlives requirements can be inferred - --> $DIR/edition-lint-infer-outlives-macro.rs:57:44 + --> $DIR/edition-lint-infer-outlives-macro.rs:57:43 | LL | macro_rules! m { ... LL | struct Bar<'a, $b>(&'a &$b ()) where $b: 'a; - | ^^^^^^^^^^^^ help: remove this bound + | ^^^^^^^^^^^^^ help: remove this bound ... LL | m!('b: 'a); | ---------- in this macro invocation @@ -83,12 +83,12 @@ LL | m!('b: 'a); | ---------- in this macro invocation error: outlives requirements can be inferred - --> $DIR/edition-lint-infer-outlives-macro.rs:117:44 + --> $DIR/edition-lint-infer-outlives-macro.rs:117:43 | LL | macro_rules! m { ... LL | struct Bar<$a, $b>(&$a &$b ()) where $b $colon $a; - | ^^^^^^^^^^^^^^^^^^ help: remove this bound + | ^^^^^^^^^^^^^^^^^^^ help: remove this bound ... LL | m!('b: 'a); | ---------- in this macro invocation @@ -105,12 +105,12 @@ LL | m!('b: 'a); | ---------- in this macro invocation error: outlives requirements can be inferred - --> $DIR/edition-lint-infer-outlives-macro.rs:132:44 + --> $DIR/edition-lint-infer-outlives-macro.rs:132:43 | LL | macro_rules! m { ... LL | struct Bar<$a, $b>(&$a &$b ()) where $b $colon $a; - | ^^^^^^^^^^^^^^^^^^ help: remove this bound + | ^^^^^^^^^^^^^^^^^^^ help: remove this bound ... LL | m!('b: 'a); | ---------- in this macro invocation diff --git a/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-multispan.stderr b/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-multispan.stderr index b2d4c3d035890..cfe01a6693426 100644 --- a/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-multispan.stderr +++ b/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives-multispan.stderr @@ -271,12 +271,12 @@ error: outlives requirements can be inferred --> $DIR/edition-lint-infer-outlives-multispan.rs:130:46 | LL | struct TeeOutlivesAyYooWhereBee<'a, 'b, T: 'a, U>(&'a T, &'b U) where U: 'b; - | ^^^^ ^^^^^^^^^^^ + | ^^^^ ^^^^^^^^^^^^ | help: remove these bounds | LL - struct TeeOutlivesAyYooWhereBee<'a, 'b, T: 'a, U>(&'a T, &'b U) where U: 'b; -LL + struct TeeOutlivesAyYooWhereBee<'a, 'b, T, U>(&'a T, &'b U) ; +LL + struct TeeOutlivesAyYooWhereBee<'a, 'b, T, U>(&'a T, &'b U); | error: outlives requirements can be inferred @@ -831,12 +831,12 @@ LL | m!(T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15); | --------------------------------------------------------- in this macro invocation error: outlives requirements can be inferred - --> $DIR/edition-lint-infer-outlives-multispan.rs:374:64 + --> $DIR/edition-lint-infer-outlives-multispan.rs:374:63 | LL | macro_rules! m { ... LL | struct FullWhere<'a, $($name,)+>(&'a ($($name,)+)) where $($name: 'a,)+; - | ^^^^^^^^^^^^^^^^^^ help: remove these bounds + | ^^^^^^^^^^^^^^^^^^^ help: remove these bounds ... LL | m!(T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15); | --------------------------------------------------------- in this macro invocation diff --git a/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives.fixed b/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives.fixed index fbf31764b6878..03a2699c4f027 100644 --- a/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives.fixed +++ b/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives.fixed @@ -253,7 +253,7 @@ mod tuple_structs { struct TeeIsDebugOutlivesAyBee<'a, 'b, T: Debug>(&'a &'b T); //~^ ERROR outlives requirements can be inferred - struct TeeWhereOutlivesAy<'a, T>(&'a T) ; + struct TeeWhereOutlivesAy<'a, T>(&'a T); //~^ ERROR outlives requirements can be inferred struct TeeWhereOutlivesAyIsDebug<'a, T>(&'a T) where T: Debug; @@ -262,7 +262,7 @@ mod tuple_structs { struct TeeWhereIsDebugOutlivesAy<'a, T>(&'a T) where T: Debug; //~^ ERROR outlives requirements can be inferred - struct TeeWhereOutlivesAyBee<'a, 'b, T>(&'a &'b T) ; + struct TeeWhereOutlivesAyBee<'a, 'b, T>(&'a &'b T); //~^ ERROR outlives requirements can be inferred struct TeeWhereOutlivesAyBeeIsDebug<'a, 'b, T>(&'a &'b T) where T: Debug; @@ -295,7 +295,7 @@ mod tuple_structs { struct TeeOutlivesAyBeeYooIsDebug<'a, 'b, T, U: Debug>(&'a &'b T, U); //~^ ERROR outlives requirements can be inferred - struct TeeYooWhereOutlivesAy<'a, T, U>(T, &'a U) ; + struct TeeYooWhereOutlivesAy<'a, T, U>(T, &'a U); //~^ ERROR outlives requirements can be inferred struct TeeYooWhereOutlivesAyIsDebug<'a, T, U>(T, &'a U) where U: Debug; @@ -307,7 +307,7 @@ mod tuple_structs { struct TeeOutlivesAyYooWhereIsDebug<'a, T, U>(&'a T, U) where U: Debug; //~^ ERROR outlives requirements can be inferred - struct TeeYooWhereOutlivesAyBee<'a, 'b, T, U>(T, &'a &'b U) ; + struct TeeYooWhereOutlivesAyBee<'a, 'b, T, U>(T, &'a &'b U); //~^ ERROR outlives requirements can be inferred struct TeeYooWhereOutlivesAyBeeIsDebug<'a, 'b, T, U>(T, &'a &'b U) where U: Debug; @@ -328,19 +328,19 @@ mod tuple_structs { struct BeeOutlivesAy<'a, 'b>(&'a &'b ()); //~^ ERROR outlives requirements can be inferred - struct BeeWhereOutlivesAy<'a, 'b>(&'a &'b ()) ; + struct BeeWhereOutlivesAy<'a, 'b>(&'a &'b ()); //~^ ERROR outlives requirements can be inferred struct BeeOutlivesAyTee<'a, 'b, T>(&'a &'b T); //~^ ERROR outlives requirements can be inferred - struct BeeWhereOutlivesAyTee<'a, 'b, T>(&'a &'b T) ; + struct BeeWhereOutlivesAyTee<'a, 'b, T>(&'a &'b T); //~^ ERROR outlives requirements can be inferred - struct BeeWhereOutlivesAyTeeWhereBee<'a, 'b, T>(&'a &'b T) ; + struct BeeWhereOutlivesAyTeeWhereBee<'a, 'b, T>(&'a &'b T); //~^ ERROR outlives requirements can be inferred - struct BeeWhereOutlivesAyTeeWhereAyBee<'a, 'b, T>(&'a &'b T) ; + struct BeeWhereOutlivesAyTeeWhereAyBee<'a, 'b, T>(&'a &'b T); //~^ ERROR outlives requirements can be inferred struct BeeOutlivesAyTeeDebug<'a, 'b, T: Debug>(&'a &'b T); diff --git a/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives.stderr b/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives.stderr index 472900b52d470..6911f46497c42 100644 --- a/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives.stderr +++ b/tests/ui/rust-2018/edition-lint-inter-outlives/edition-lint-infer-outlives.stderr @@ -283,10 +283,10 @@ LL | struct TeeIsDebugOutlivesAyBee<'a, 'b, T: Debug + 'a + 'b>(&'a &'b T); | ^^^^^^^^^^ help: remove these bounds error: outlives requirements can be inferred - --> $DIR/edition-lint-infer-outlives.rs:256:45 + --> $DIR/edition-lint-infer-outlives.rs:256:44 | LL | struct TeeWhereOutlivesAy<'a, T>(&'a T) where T: 'a; - | ^^^^^^^^^^^ help: remove this bound + | ^^^^^^^^^^^^ help: remove this bound error: outlives requirements can be inferred --> $DIR/edition-lint-infer-outlives.rs:259:61 @@ -301,10 +301,10 @@ LL | struct TeeWhereIsDebugOutlivesAy<'a, T>(&'a T) where T: Debug + 'a; | ^^^^^ help: remove this bound error: outlives requirements can be inferred - --> $DIR/edition-lint-infer-outlives.rs:265:56 + --> $DIR/edition-lint-infer-outlives.rs:265:55 | LL | struct TeeWhereOutlivesAyBee<'a, 'b, T>(&'a &'b T) where T: 'a + 'b; - | ^^^^^^^^^^^^^^^^ help: remove these bounds + | ^^^^^^^^^^^^^^^^^ help: remove these bounds error: outlives requirements can be inferred --> $DIR/edition-lint-infer-outlives.rs:268:72 @@ -367,10 +367,10 @@ LL | struct TeeOutlivesAyBeeYooIsDebug<'a, 'b, T: 'a + 'b, U: Debug>(&'a &'b | ^^^^^^^^^ help: remove these bounds error: outlives requirements can be inferred - --> $DIR/edition-lint-infer-outlives.rs:298:54 + --> $DIR/edition-lint-infer-outlives.rs:298:53 | LL | struct TeeYooWhereOutlivesAy<'a, T, U>(T, &'a U) where U: 'a; - | ^^^^^^^^^^^ help: remove this bound + | ^^^^^^^^^^^^ help: remove this bound error: outlives requirements can be inferred --> $DIR/edition-lint-infer-outlives.rs:301:70 @@ -391,10 +391,10 @@ LL | struct TeeOutlivesAyYooWhereIsDebug<'a, T: 'a, U>(&'a T, U) where U: De | ^^^^ help: remove this bound error: outlives requirements can be inferred - --> $DIR/edition-lint-infer-outlives.rs:310:65 + --> $DIR/edition-lint-infer-outlives.rs:310:64 | LL | struct TeeYooWhereOutlivesAyBee<'a, 'b, T, U>(T, &'a &'b U) where U: 'a + 'b; - | ^^^^^^^^^^^^^^^^ help: remove these bounds + | ^^^^^^^^^^^^^^^^^ help: remove these bounds error: outlives requirements can be inferred --> $DIR/edition-lint-infer-outlives.rs:313:81 @@ -433,10 +433,10 @@ LL | struct BeeOutlivesAy<'a, 'b: 'a>(&'a &'b ()); | ^^^^ help: remove this bound error: outlives requirements can be inferred - --> $DIR/edition-lint-infer-outlives.rs:331:51 + --> $DIR/edition-lint-infer-outlives.rs:331:50 | LL | struct BeeWhereOutlivesAy<'a, 'b>(&'a &'b ()) where 'b: 'a; - | ^^^^^^^^^^^^ help: remove this bound + | ^^^^^^^^^^^^^ help: remove this bound error: outlives requirements can be inferred --> $DIR/edition-lint-infer-outlives.rs:334:35 @@ -445,22 +445,22 @@ LL | struct BeeOutlivesAyTee<'a, 'b: 'a, T>(&'a &'b T); | ^^^^ help: remove this bound error: outlives requirements can be inferred - --> $DIR/edition-lint-infer-outlives.rs:337:56 + --> $DIR/edition-lint-infer-outlives.rs:337:55 | LL | struct BeeWhereOutlivesAyTee<'a, 'b, T>(&'a &'b T) where 'b: 'a; - | ^^^^^^^^^^^^ help: remove this bound + | ^^^^^^^^^^^^^ help: remove this bound error: outlives requirements can be inferred - --> $DIR/edition-lint-infer-outlives.rs:340:64 + --> $DIR/edition-lint-infer-outlives.rs:340:63 | LL | struct BeeWhereOutlivesAyTeeWhereBee<'a, 'b, T>(&'a &'b T) where 'b: 'a, T: 'b; - | ^^^^^^^^^^^^^^^^^^^ help: remove these bounds + | ^^^^^^^^^^^^^^^^^^^^ help: remove these bounds error: outlives requirements can be inferred - --> $DIR/edition-lint-infer-outlives.rs:343:66 + --> $DIR/edition-lint-infer-outlives.rs:343:65 | LL | struct BeeWhereOutlivesAyTeeWhereAyBee<'a, 'b, T>(&'a &'b T) where 'b: 'a, T: 'a + 'b; - | ^^^^^^^^^^^^^^^^^^^^^^^^ help: remove these bounds + | ^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove these bounds error: outlives requirements can be inferred --> $DIR/edition-lint-infer-outlives.rs:346:40 diff --git a/tests/ui/type/pattern_types/assoc_const.default.stderr b/tests/ui/type/pattern_types/assoc_const.default.stderr index 8b1184877af83..db79eaff48753 100644 --- a/tests/ui/type/pattern_types/assoc_const.default.stderr +++ b/tests/ui/type/pattern_types/assoc_const.default.stderr @@ -1,5 +1,5 @@ error: generic parameters may not be used in const operations - --> $DIR/assoc_const.rs:17:41 + --> $DIR/assoc_const.rs:15:41 | LL | fn foo(_: pattern_type!(u32 is ::START..=::END)) {} | ^ cannot perform const operation using `T` @@ -9,7 +9,7 @@ LL | fn foo(_: pattern_type!(u32 is ::START..=::END) = help: alternatively, you can use `#![feature(gca_const_items)]` and wrap the expression in the `gca!` macro error: generic parameters may not be used in const operations - --> $DIR/assoc_const.rs:17:61 + --> $DIR/assoc_const.rs:15:61 | LL | fn foo(_: pattern_type!(u32 is ::START..=::END)) {} | ^ cannot perform const operation using `T` @@ -19,7 +19,7 @@ LL | fn foo(_: pattern_type!(u32 is ::START..=::END) = help: alternatively, you can use `#![feature(gca_const_items)]` and wrap the expression in the `gca!` macro error: generic parameters may not be used in const operations - --> $DIR/assoc_const.rs:20:40 + --> $DIR/assoc_const.rs:18:40 | LL | fn bar(_: pattern_type!(u32 is T::START..=T::END)) {} | ^ cannot perform const operation using `T` @@ -29,7 +29,7 @@ LL | fn bar(_: pattern_type!(u32 is T::START..=T::END)) {} = help: alternatively, you can use `#![feature(gca_const_items)]` and wrap the expression in the `gca!` macro error: generic parameters may not be used in const operations - --> $DIR/assoc_const.rs:20:51 + --> $DIR/assoc_const.rs:18:51 | LL | fn bar(_: pattern_type!(u32 is T::START..=T::END)) {} | ^ cannot perform const operation using `T` diff --git a/tests/ui/type/pattern_types/assoc_const.rs b/tests/ui/type/pattern_types/assoc_const.rs index 90508801990e8..6b5de2042f5d0 100644 --- a/tests/ui/type/pattern_types/assoc_const.rs +++ b/tests/ui/type/pattern_types/assoc_const.rs @@ -1,7 +1,5 @@ #![feature(pattern_types)] -#![feature(pattern_type_macro)] #![cfg_attr(const_arg, feature(generic_const_exprs, generic_pattern_types))] -#![expect(incomplete_features)] // gate-test-generic_pattern_types line to the test file. //@ revisions: default const_arg diff --git a/tests/ui/type/pattern_types/bad_pat.rs b/tests/ui/type/pattern_types/bad_pat.rs index 7e2b4cb996f27..75c8169188011 100644 --- a/tests/ui/type/pattern_types/bad_pat.rs +++ b/tests/ui/type/pattern_types/bad_pat.rs @@ -1,5 +1,4 @@ #![feature(pattern_types)] -#![feature(pattern_type_macro)] use std::pat::pattern_type; @@ -12,7 +11,7 @@ type Wild = pattern_type!(() is _); // FIXME: confusing diagnostic because `not` can be a binding type NonNull = pattern_type!(*const () is not null); -//~^ ERROR: expected one of `@` or `|`, found `null` +//~^ ERROR: expected one of //~| ERROR: pattern not supported in pattern types type NonNull2 = pattern_type!(*const () is !nil); diff --git a/tests/ui/type/pattern_types/bad_pat.stderr b/tests/ui/type/pattern_types/bad_pat.stderr index e72279542280c..07ced579c6512 100644 --- a/tests/ui/type/pattern_types/bad_pat.stderr +++ b/tests/ui/type/pattern_types/bad_pat.stderr @@ -1,5 +1,5 @@ error[E0586]: inclusive range with no end - --> $DIR/bad_pat.rs:6:43 + --> $DIR/bad_pat.rs:5:43 | LL | type NonNullU32_2 = pattern_type!(u32 is 1..=); | ^^^ @@ -12,7 +12,7 @@ LL + type NonNullU32_2 = pattern_type!(u32 is 1..); | error[E0586]: inclusive range with no end - --> $DIR/bad_pat.rs:8:40 + --> $DIR/bad_pat.rs:7:40 | LL | type Positive2 = pattern_type!(i32 is 0..=); | ^^^ @@ -25,25 +25,25 @@ LL + type Positive2 = pattern_type!(i32 is 0..); | error: pattern not supported in pattern types - --> $DIR/bad_pat.rs:10:33 + --> $DIR/bad_pat.rs:9:33 | LL | type Wild = pattern_type!(() is _); | ^ error: pattern not supported in pattern types - --> $DIR/bad_pat.rs:14:43 + --> $DIR/bad_pat.rs:13:43 | LL | type NonNull = pattern_type!(*const () is not null); | ^^^ -error: expected one of `@` or `|`, found `null` - --> $DIR/bad_pat.rs:14:47 +error: expected one of `)`, `@`, or `|`, found `null` + --> $DIR/bad_pat.rs:13:47 | LL | type NonNull = pattern_type!(*const () is not null); - | ^^^^ expected one of `@` or `|` + | ^^^^ expected one of `)`, `@`, or `|` error: expected `null`, found `nil` - --> $DIR/bad_pat.rs:18:45 + --> $DIR/bad_pat.rs:17:45 | LL | type NonNull2 = pattern_type!(*const () is !nil); | ^^^ expected `null` diff --git a/tests/ui/type/pattern_types/chars.rs b/tests/ui/type/pattern_types/chars.rs index 9073998b387b7..285c4f3abdf75 100644 --- a/tests/ui/type/pattern_types/chars.rs +++ b/tests/ui/type/pattern_types/chars.rs @@ -3,7 +3,6 @@ //@ check-pass #![feature(pattern_types)] -#![feature(pattern_type_macro)] use std::pat::pattern_type; diff --git a/tests/ui/type/pattern_types/const_generics.rs b/tests/ui/type/pattern_types/const_generics.rs index f5eb90e94d4fd..aff5e72f2c9e8 100644 --- a/tests/ui/type/pattern_types/const_generics.rs +++ b/tests/ui/type/pattern_types/const_generics.rs @@ -3,7 +3,7 @@ //@ ignore-compare-mode-next-solver (explicit revisions) //@[next] compile-flags: -Znext-solver -#![feature(pattern_types, generic_pattern_types, pattern_type_macro)] +#![feature(pattern_types, generic_pattern_types)] #![expect(incomplete_features)] use std::pat::pattern_type; diff --git a/tests/ui/type/pattern_types/derives.rs b/tests/ui/type/pattern_types/derives.rs index 12af19e5f7ea6..2a3d1164c9772 100644 --- a/tests/ui/type/pattern_types/derives.rs +++ b/tests/ui/type/pattern_types/derives.rs @@ -2,7 +2,6 @@ //! Exceptions are `Clone` and `Copy`, which have builtin impls for pattern types. #![feature(pattern_types)] -#![feature(pattern_type_macro)] use std::pat::pattern_type; @@ -11,7 +10,7 @@ use std::pat::pattern_type; struct Nanoseconds(NanoI32); //~^ ERROR: binary operation `==` cannot be applied to type `pattern_type!(i32 is 0..=999999999)` -type NanoI32 = crate::pattern_type!(i32 is 0..=999_999_999); +type NanoI32 = pattern_type!(i32 is 0..=999_999_999); fn main() { let x = Nanoseconds(unsafe { std::mem::transmute(42) }); diff --git a/tests/ui/type/pattern_types/derives.stderr b/tests/ui/type/pattern_types/derives.stderr index 6fb0c0994082a..f196cec5a1dc5 100644 --- a/tests/ui/type/pattern_types/derives.stderr +++ b/tests/ui/type/pattern_types/derives.stderr @@ -1,5 +1,5 @@ error[E0369]: binary operation `==` cannot be applied to type `pattern_type!(i32 is 0..=999999999)` - --> $DIR/derives.rs:11:20 + --> $DIR/derives.rs:10:20 | LL | #[derive(Clone, Copy, PartialEq)] | --------- in this derive macro expansion diff --git a/tests/ui/type/pattern_types/derives_fail.rs b/tests/ui/type/pattern_types/derives_fail.rs index 8251fa9f38c0b..60b4eb06db901 100644 --- a/tests/ui/type/pattern_types/derives_fail.rs +++ b/tests/ui/type/pattern_types/derives_fail.rs @@ -2,7 +2,6 @@ //! Exceptions are `Clone` and `Copy`, which have bultin impls for pattern types. #![feature(pattern_types)] -#![feature(pattern_type_macro)] use std::pat::pattern_type; @@ -16,7 +15,7 @@ struct Nanoseconds(NanoI32); //~| ERROR: the trait bound `pattern_type!(i32 is 0..=999999999): Default` is not satisfied //~| ERROR: `==` cannot be applied -type NanoI32 = crate::pattern_type!(i32 is 0..=999_999_999); +type NanoI32 = pattern_type!(i32 is 0..=999_999_999); fn main() { let x = Nanoseconds(unsafe { std::mem::transmute(42) }); diff --git a/tests/ui/type/pattern_types/derives_fail.stderr b/tests/ui/type/pattern_types/derives_fail.stderr index a6814d8cba2a0..ac194b9be8990 100644 --- a/tests/ui/type/pattern_types/derives_fail.stderr +++ b/tests/ui/type/pattern_types/derives_fail.stderr @@ -1,5 +1,5 @@ error[E0369]: binary operation `==` cannot be applied to type `pattern_type!(i32 is 0..=999999999)` - --> $DIR/derives_fail.rs:11:20 + --> $DIR/derives_fail.rs:10:20 | LL | #[derive(Clone, Copy, PartialEq, Eq, Debug, Ord, PartialOrd, Hash, Default)] | --------- in this derive macro expansion @@ -8,7 +8,7 @@ LL | struct Nanoseconds(NanoI32); | ^^^^^^^ error[E0277]: the trait bound `pattern_type!(i32 is 0..=999999999): Eq` is not satisfied - --> $DIR/derives_fail.rs:11:20 + --> $DIR/derives_fail.rs:10:20 | LL | #[derive(Clone, Copy, PartialEq, Eq, Debug, Ord, PartialOrd, Hash, Default)] | -- in this derive macro expansion @@ -20,7 +20,7 @@ note: required by a bound in `std::cmp::AssertParamIsEq` --> $SRC_DIR/core/src/cmp.rs:LL:COL error[E0277]: `pattern_type!(i32 is 0..=999999999)` doesn't implement `Debug` - --> $DIR/derives_fail.rs:11:20 + --> $DIR/derives_fail.rs:10:20 | LL | #[derive(Clone, Copy, PartialEq, Eq, Debug, Ord, PartialOrd, Hash, Default)] | ----- in this derive macro expansion @@ -29,7 +29,7 @@ LL | struct Nanoseconds(NanoI32); | ^^^^^^^ the trait `Debug` is not implemented for `pattern_type!(i32 is 0..=999999999)` error[E0277]: the trait bound `pattern_type!(i32 is 0..=999999999): Ord` is not satisfied - --> $DIR/derives_fail.rs:11:20 + --> $DIR/derives_fail.rs:10:20 | LL | #[derive(Clone, Copy, PartialEq, Eq, Debug, Ord, PartialOrd, Hash, Default)] | --- in this derive macro expansion @@ -38,7 +38,7 @@ LL | struct Nanoseconds(NanoI32); | ^^^^^^^ the trait `Ord` is not implemented for `pattern_type!(i32 is 0..=999999999)` error[E0277]: the trait bound `pattern_type!(i32 is 0..=999999999): Hash` is not satisfied - --> $DIR/derives_fail.rs:11:20 + --> $DIR/derives_fail.rs:10:20 | LL | #[derive(Clone, Copy, PartialEq, Eq, Debug, Ord, PartialOrd, Hash, Default)] | ---- in this derive macro expansion @@ -47,7 +47,7 @@ LL | struct Nanoseconds(NanoI32); | ^^^^^^^ the trait `Hash` is not implemented for `pattern_type!(i32 is 0..=999999999)` error[E0277]: the trait bound `pattern_type!(i32 is 0..=999999999): Default` is not satisfied - --> $DIR/derives_fail.rs:11:20 + --> $DIR/derives_fail.rs:10:20 | LL | #[derive(Clone, Copy, PartialEq, Eq, Debug, Ord, PartialOrd, Hash, Default)] | ------- in this derive macro expansion diff --git a/tests/ui/type/pattern_types/feature-gate-pattern_types.stderr b/tests/ui/type/pattern_types/feature-gate-pattern_types.disabled.stderr similarity index 64% rename from tests/ui/type/pattern_types/feature-gate-pattern_types.stderr rename to tests/ui/type/pattern_types/feature-gate-pattern_types.disabled.stderr index 12508bcb54a34..b03af26289efc 100644 --- a/tests/ui/type/pattern_types/feature-gate-pattern_types.stderr +++ b/tests/ui/type/pattern_types/feature-gate-pattern_types.disabled.stderr @@ -1,55 +1,55 @@ -error[E0658]: use of unstable library feature `pattern_type_macro` - --> $DIR/feature-gate-pattern_types.rs:5:19 +error[E0658]: use of unstable library feature `pattern_types` + --> $DIR/feature-gate-pattern_types.rs:7:19 | LL | type NonNullU32 = pattern_type!(u32 is 1..); | ^^^^^^^^^^^^ | = note: see issue #123646 for more information - = help: add `#![feature(pattern_type_macro)]` to the crate attributes to enable + = help: add `#![feature(pattern_types)]` to the crate attributes to enable = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date -error[E0658]: use of unstable library feature `pattern_type_macro` - --> $DIR/feature-gate-pattern_types.rs:7:16 +error[E0658]: use of unstable library feature `pattern_types` + --> $DIR/feature-gate-pattern_types.rs:9:16 | LL | type Percent = pattern_type!(u32 is 0..=100); | ^^^^^^^^^^^^ | = note: see issue #123646 for more information - = help: add `#![feature(pattern_type_macro)]` to the crate attributes to enable + = help: add `#![feature(pattern_types)]` to the crate attributes to enable = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date -error[E0658]: use of unstable library feature `pattern_type_macro` - --> $DIR/feature-gate-pattern_types.rs:9:17 +error[E0658]: use of unstable library feature `pattern_types` + --> $DIR/feature-gate-pattern_types.rs:11:17 | LL | type Negative = pattern_type!(i32 is ..=0); | ^^^^^^^^^^^^ | = note: see issue #123646 for more information - = help: add `#![feature(pattern_type_macro)]` to the crate attributes to enable + = help: add `#![feature(pattern_types)]` to the crate attributes to enable = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date -error[E0658]: use of unstable library feature `pattern_type_macro` - --> $DIR/feature-gate-pattern_types.rs:11:17 +error[E0658]: use of unstable library feature `pattern_types` + --> $DIR/feature-gate-pattern_types.rs:13:17 | LL | type Positive = pattern_type!(i32 is 0..); | ^^^^^^^^^^^^ | = note: see issue #123646 for more information - = help: add `#![feature(pattern_type_macro)]` to the crate attributes to enable + = help: add `#![feature(pattern_types)]` to the crate attributes to enable = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date -error[E0658]: use of unstable library feature `pattern_type_macro` - --> $DIR/feature-gate-pattern_types.rs:13:15 +error[E0658]: use of unstable library feature `pattern_types` + --> $DIR/feature-gate-pattern_types.rs:15:15 | LL | type Always = pattern_type!(Option is Some(_)); | ^^^^^^^^^^^^ | = note: see issue #123646 for more information - = help: add `#![feature(pattern_type_macro)]` to the crate attributes to enable + = help: add `#![feature(pattern_types)]` to the crate attributes to enable = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date error: pattern not supported in pattern types - --> $DIR/feature-gate-pattern_types.rs:13:44 + --> $DIR/feature-gate-pattern_types.rs:15:44 | LL | type Always = pattern_type!(Option is Some(_)); | ^^^^^^^ diff --git a/tests/ui/type/pattern_types/feature-gate-pattern_types2.stderr b/tests/ui/type/pattern_types/feature-gate-pattern_types.enabled.stderr similarity index 81% rename from tests/ui/type/pattern_types/feature-gate-pattern_types2.stderr rename to tests/ui/type/pattern_types/feature-gate-pattern_types.enabled.stderr index 81bf9dea0e2fd..c77bbd2756bf0 100644 --- a/tests/ui/type/pattern_types/feature-gate-pattern_types2.stderr +++ b/tests/ui/type/pattern_types/feature-gate-pattern_types.enabled.stderr @@ -1,5 +1,5 @@ error: pattern not supported in pattern types - --> $DIR/feature-gate-pattern_types2.rs:11:44 + --> $DIR/feature-gate-pattern_types.rs:15:44 | LL | type Always = pattern_type!(Option is Some(_)); | ^^^^^^^ diff --git a/tests/ui/type/pattern_types/feature-gate-pattern_types.rs b/tests/ui/type/pattern_types/feature-gate-pattern_types.rs index a51741675bbd6..91241c00d56c9 100644 --- a/tests/ui/type/pattern_types/feature-gate-pattern_types.rs +++ b/tests/ui/type/pattern_types/feature-gate-pattern_types.rs @@ -1,15 +1,17 @@ +//@ revisions: disabled enabled //@ compile-flags: -Zno-analysis +#![cfg_attr(enabled, feature(pattern_types))] use std::pat::pattern_type; type NonNullU32 = pattern_type!(u32 is 1..); -//~^ ERROR use of unstable library feature `pattern_type_macro` +//[disabled]~^ ERROR use of unstable library feature `pattern_types` type Percent = pattern_type!(u32 is 0..=100); -//~^ ERROR use of unstable library feature `pattern_type_macro` +//[disabled]~^ ERROR use of unstable library feature `pattern_types` type Negative = pattern_type!(i32 is ..=0); -//~^ ERROR use of unstable library feature `pattern_type_macro` +//[disabled]~^ ERROR use of unstable library feature `pattern_types` type Positive = pattern_type!(i32 is 0..); -//~^ ERROR use of unstable library feature `pattern_type_macro` +//[disabled]~^ ERROR use of unstable library feature `pattern_types` type Always = pattern_type!(Option is Some(_)); -//~^ ERROR use of unstable library feature `pattern_type_macro` -//~| ERROR pattern not supported in pattern types +//[disabled]~^ ERROR use of unstable library feature `pattern_types` +//~^^ ERROR pattern not supported in pattern types diff --git a/tests/ui/type/pattern_types/feature-gate-pattern_types2.rs b/tests/ui/type/pattern_types/feature-gate-pattern_types2.rs deleted file mode 100644 index c6b4b325fa35a..0000000000000 --- a/tests/ui/type/pattern_types/feature-gate-pattern_types2.rs +++ /dev/null @@ -1,12 +0,0 @@ -//@ compile-flags: -Zno-analysis - -#![feature(pattern_type_macro)] - -use std::pat::pattern_type; - -type NonNullU32 = pattern_type!(u32 is 1..); -type Percent = pattern_type!(u32 is 0..=100); -type Negative = pattern_type!(i32 is ..=0); -type Positive = pattern_type!(i32 is 0..); -type Always = pattern_type!(Option is Some(_)); -//~^ ERROR: pattern not supported in pattern types diff --git a/tests/ui/type/pattern_types/free_const.rs b/tests/ui/type/pattern_types/free_const.rs index 2e29fce237970..96601622a352f 100644 --- a/tests/ui/type/pattern_types/free_const.rs +++ b/tests/ui/type/pattern_types/free_const.rs @@ -1,7 +1,6 @@ //@ check-pass #![feature(pattern_types)] -#![feature(pattern_type_macro)] use std::pat::pattern_type; diff --git a/tests/ui/type/pattern_types/literals.rs b/tests/ui/type/pattern_types/literals.rs index 5ec15d1b6bd8e..407123ca8f7ef 100644 --- a/tests/ui/type/pattern_types/literals.rs +++ b/tests/ui/type/pattern_types/literals.rs @@ -1,7 +1,6 @@ //! Check where literals can be used to initialize pattern types and where not. #![feature(pattern_types, const_trait_impl, pattern_type_range_trait)] -#![feature(pattern_type_macro)] use std::pat::pattern_type; diff --git a/tests/ui/type/pattern_types/literals.stderr b/tests/ui/type/pattern_types/literals.stderr index caf5667c8f314..f36c477126020 100644 --- a/tests/ui/type/pattern_types/literals.stderr +++ b/tests/ui/type/pattern_types/literals.stderr @@ -1,35 +1,35 @@ error[E0080]: evaluation panicked: exclusive range end at minimum value of type - --> $DIR/literals.rs:86:62 + --> $DIR/literals.rs:85:62 | LL | fn empty_range_at_base_type_min() -> pattern_type!(u32 is 0..0) { | ^ evaluation of `empty_range_at_base_type_min::{constant#1}` failed here error[E0080]: evaluation panicked: exclusive range end at minimum value of type - --> $DIR/literals.rs:91:63 + --> $DIR/literals.rs:90:63 | LL | fn empty_range_at_base_type_min2() -> pattern_type!(u32 is 0..0) { | ^ evaluation of `empty_range_at_base_type_min2::{constant#1}` failed here error[E0080]: evaluation panicked: exclusive range end at minimum value of type - --> $DIR/literals.rs:106:65 + --> $DIR/literals.rs:105:65 | LL | fn wraparound_range_at_base_ty_end() -> pattern_type!(u32 is 1..0) { | ^ evaluation of `wraparound_range_at_base_ty_end::{constant#1}` failed here error[E0080]: evaluation panicked: exclusive range end at minimum value of type - --> $DIR/literals.rs:111:66 + --> $DIR/literals.rs:110:66 | LL | fn wraparound_range_at_base_ty_end2() -> pattern_type!(u32 is 1..0) { | ^ evaluation of `wraparound_range_at_base_ty_end2::{constant#1}` failed here error[E0080]: evaluation panicked: exclusive range end at minimum value of type - --> $DIR/literals.rs:116:66 + --> $DIR/literals.rs:115:66 | LL | fn wraparound_range_at_base_ty_end3() -> pattern_type!(u32 is 1..0) { | ^ evaluation of `wraparound_range_at_base_ty_end3::{constant#1}` failed here error[E0308]: mismatched types - --> $DIR/literals.rs:9:5 + --> $DIR/literals.rs:8:5 | LL | fn out_of_range() -> pattern_type!(u32 is 1..) { | ------------------------- expected `pattern_type!(u32 is 1..)` because of return type @@ -40,19 +40,19 @@ LL | 0 found type `{integer}` error[E0600]: cannot apply unary operator `-` to type `pattern_type!(u32 is 1..)` - --> $DIR/literals.rs:22:5 + --> $DIR/literals.rs:21:5 | LL | -3 | ^^ cannot apply unary operator `-` error[E0600]: cannot apply unary operator `-` to type `pattern_type!(i8 is -5..=4)` - --> $DIR/literals.rs:27:5 + --> $DIR/literals.rs:26:5 | LL | -2 | ^^ cannot apply unary operator `-` error[E0308]: mismatched types - --> $DIR/literals.rs:36:5 + --> $DIR/literals.rs:35:5 | LL | fn negative_lit_at_range_start() -> pattern_type!(i8 is -5..5) { | -------------------------- expected `pattern_type!(i8 is -5..=4)` because of return type @@ -63,7 +63,7 @@ LL | -5 found type `{integer}` error[E0308]: mismatched types - --> $DIR/literals.rs:45:5 + --> $DIR/literals.rs:44:5 | LL | fn lit_one_beyond_range_end() -> pattern_type!(i8 is -5..5) { | -------------------------- expected `pattern_type!(i8 is -5..=4)` because of return type @@ -74,7 +74,7 @@ LL | 5 found type `{integer}` error[E0308]: mismatched types - --> $DIR/literals.rs:50:5 + --> $DIR/literals.rs:49:5 | LL | fn wrong_lit_kind() -> pattern_type!(u32 is 1..) { | ------------------------- expected `pattern_type!(u32 is 1..)` because of return type @@ -85,7 +85,7 @@ LL | '3' found type `char` error[E0308]: mismatched types - --> $DIR/literals.rs:55:5 + --> $DIR/literals.rs:54:5 | LL | fn char_lit_in_range() -> pattern_type!(char is 'a'..'z') { | ------------------------------- expected `pattern_type!(char is 'a'..='y')` because of return type @@ -96,7 +96,7 @@ LL | 'b' found type `char` error[E0308]: mismatched types - --> $DIR/literals.rs:60:5 + --> $DIR/literals.rs:59:5 | LL | fn char_lit_out_of_range() -> pattern_type!(char is 'a'..'z') { | ------------------------------- expected `pattern_type!(char is 'a'..='y')` because of return type @@ -107,7 +107,7 @@ LL | 'A' found type `char` error[E0308]: mismatched types - --> $DIR/literals.rs:73:5 + --> $DIR/literals.rs:72:5 | LL | fn lit_oob_single_element_range() -> pattern_type!(u32 is 0..=0) { | --------------------------- expected `pattern_type!(u32 is 0..=0)` because of return type @@ -118,7 +118,7 @@ LL | 1 found type `{integer}` error[E0308]: mismatched types - --> $DIR/literals.rs:78:5 + --> $DIR/literals.rs:77:5 | LL | fn lit_oob_single_element_range_exclusive() -> pattern_type!(u32 is 0..1) { | -------------------------- expected `pattern_type!(u32 is 0..=0)` because of return type @@ -131,7 +131,7 @@ LL | 1 error: pattern type ranges cannot wrap: 1..=0 error[E0308]: mismatched types - --> $DIR/literals.rs:97:5 + --> $DIR/literals.rs:96:5 | LL | fn empty_range() -> pattern_type!(u32 is 1..1) { | -------------------------- expected `pattern_type!(u32 is 1..=0)` because of return type @@ -142,7 +142,7 @@ LL | 0 found type `{integer}` error[E0308]: mismatched types - --> $DIR/literals.rs:102:5 + --> $DIR/literals.rs:101:5 | LL | fn empty_range2() -> pattern_type!(u32 is 1..1) { | -------------------------- expected `pattern_type!(u32 is 1..=0)` because of return type @@ -155,7 +155,7 @@ LL | 1 error: pattern type ranges cannot wrap: 2..=0 error[E0308]: mismatched types - --> $DIR/literals.rs:122:5 + --> $DIR/literals.rs:121:5 | LL | fn wraparound_range() -> pattern_type!(u32 is 2..1) { | -------------------------- expected `pattern_type!(u32 is 2..=0)` because of return type @@ -166,7 +166,7 @@ LL | 1 found type `{integer}` error[E0308]: mismatched types - --> $DIR/literals.rs:127:5 + --> $DIR/literals.rs:126:5 | LL | fn lit_in_wraparound_range() -> pattern_type!(u32 is 2..1) { | -------------------------- expected `pattern_type!(u32 is 2..=0)` because of return type @@ -177,7 +177,7 @@ LL | 0 found type `{integer}` error[E0308]: mismatched types - --> $DIR/literals.rs:132:5 + --> $DIR/literals.rs:131:5 | LL | fn lit_at_wraparound_range_start() -> pattern_type!(u32 is 2..1) { | -------------------------- expected `pattern_type!(u32 is 2..=0)` because of return type diff --git a/tests/ui/type/pattern_types/matching.rs b/tests/ui/type/pattern_types/matching.rs index 21f89b3b673be..1086baab876c1 100644 --- a/tests/ui/type/pattern_types/matching.rs +++ b/tests/ui/type/pattern_types/matching.rs @@ -1,4 +1,4 @@ -#![feature(pattern_types, pattern_type_macro, structural_match)] +#![feature(pattern_types, structural_match)] //@ check-pass //@ compile-flags: -Zvalidate-mir diff --git a/tests/ui/type/pattern_types/matching_fail.rs b/tests/ui/type/pattern_types/matching_fail.rs index 8e2c741e3e0ab..2a345635378a6 100644 --- a/tests/ui/type/pattern_types/matching_fail.rs +++ b/tests/ui/type/pattern_types/matching_fail.rs @@ -1,4 +1,4 @@ -#![feature(pattern_types, pattern_type_macro, structural_match)] +#![feature(pattern_types, structural_match)] use std::pat::pattern_type; diff --git a/tests/ui/type/pattern_types/missing-is.rs b/tests/ui/type/pattern_types/missing-is.rs index 564b41649d899..619f37eb007e0 100644 --- a/tests/ui/type/pattern_types/missing-is.rs +++ b/tests/ui/type/pattern_types/missing-is.rs @@ -1,4 +1,4 @@ -#![feature(pattern_type_macro)] +#![feature(pattern_types)] use std::pat::pattern_type; diff --git a/tests/ui/type/pattern_types/nested.rs b/tests/ui/type/pattern_types/nested.rs index bff83dd43902b..96fbfea9e5e6f 100644 --- a/tests/ui/type/pattern_types/nested.rs +++ b/tests/ui/type/pattern_types/nested.rs @@ -1,7 +1,6 @@ //! Check that pattern types can only have specific base types #![feature(pattern_types, const_trait_impl, pattern_type_range_trait)] -#![feature(pattern_type_macro)] use std::pat::pattern_type; diff --git a/tests/ui/type/pattern_types/nested.stderr b/tests/ui/type/pattern_types/nested.stderr index 72f0ccc1bfb9f..f75405241ae9e 100644 --- a/tests/ui/type/pattern_types/nested.stderr +++ b/tests/ui/type/pattern_types/nested.stderr @@ -1,5 +1,5 @@ error[E0308]: mismatched types - --> $DIR/nested.rs:10:63 + --> $DIR/nested.rs:9:63 | LL | const BAD_NESTING: pattern_type!(pattern_type!(u32 is 1..) is 0..) = todo!(); | ------------------------- ^ expected `pattern_type!(u32 is 1..)`, found integer @@ -10,7 +10,7 @@ LL | const BAD_NESTING: pattern_type!(pattern_type!(u32 is 1..) is 0..) = todo!( found type `{integer}` error[E0277]: `pattern_type!(u32 is 1..)` is not a valid base type for range patterns - --> $DIR/nested.rs:10:34 + --> $DIR/nested.rs:9:34 | LL | const BAD_NESTING: pattern_type!(pattern_type!(u32 is 1..) is 0..) = todo!(); | ^^^^^^^^^^^^^^^^^^^^^^^^^ only integer types and `char` are supported @@ -28,7 +28,7 @@ LL | const BAD_NESTING: pattern_type!(pattern_type!(u32 is 1..) is 0..) = todo!( and 5 others error[E0277]: `pattern_type!(i32 is 1..)` is not a valid base type for range patterns - --> $DIR/nested.rs:15:35 + --> $DIR/nested.rs:14:35 | LL | const BAD_NESTING2: pattern_type!(pattern_type!(i32 is 1..) is ..=-1) = todo!(); | ^^^^^^^^^^^^^^^^^^^^^^^^^ only integer types and `char` are supported @@ -46,13 +46,13 @@ LL | const BAD_NESTING2: pattern_type!(pattern_type!(i32 is 1..) is ..=-1) = tod and 5 others error[E0600]: cannot apply unary operator `-` to type `pattern_type!(i32 is 1..)` - --> $DIR/nested.rs:15:67 + --> $DIR/nested.rs:14:67 | LL | const BAD_NESTING2: pattern_type!(pattern_type!(i32 is 1..) is ..=-1) = todo!(); | ^^ cannot apply unary operator `-` error[E0277]: `pattern_type!(i32 is 1..)` is not a valid base type for range patterns - --> $DIR/nested.rs:19:35 + --> $DIR/nested.rs:18:35 | LL | const BAD_NESTING3: pattern_type!(pattern_type!(i32 is 1..) is ..0) = todo!(); | ^^^^^^^^^^^^^^^^^^^^^^^^^ only integer types and `char` are supported @@ -70,7 +70,7 @@ LL | const BAD_NESTING3: pattern_type!(pattern_type!(i32 is 1..) is ..0) = todo! and 5 others error[E0308]: mismatched types - --> $DIR/nested.rs:19:66 + --> $DIR/nested.rs:18:66 | LL | const BAD_NESTING3: pattern_type!(pattern_type!(i32 is 1..) is ..0) = todo!(); | ^ @@ -81,7 +81,7 @@ LL | const BAD_NESTING3: pattern_type!(pattern_type!(i32 is 1..) is ..0) = todo! = note: expected pattern type `pattern_type!(i32 is 1..)` found type `{integer}` help: the return type of this call is `{integer}` due to the type of the argument passed - --> $DIR/nested.rs:19:66 + --> $DIR/nested.rs:18:66 | LL | const BAD_NESTING3: pattern_type!(pattern_type!(i32 is 1..) is ..0) = todo!(); | ^ this argument influences the return type of `RangeSub` @@ -89,7 +89,7 @@ note: method defined here --> $SRC_DIR/core/src/pat.rs:LL:COL error[E0277]: `pattern_type!(i32 is 1..)` is not a valid base type for range patterns - --> $DIR/nested.rs:19:66 + --> $DIR/nested.rs:18:66 | LL | const BAD_NESTING3: pattern_type!(pattern_type!(i32 is 1..) is ..0) = todo!(); | ^ only integer types and `char` are supported @@ -107,7 +107,7 @@ LL | const BAD_NESTING3: pattern_type!(pattern_type!(i32 is 1..) is ..0) = todo! and 5 others error[E0277]: `()` is not a valid base type for range patterns - --> $DIR/nested.rs:24:35 + --> $DIR/nested.rs:23:35 | LL | const BAD_NESTING4: pattern_type!(() is ..0) = todo!(); | ^^ only integer types and `char` are supported @@ -125,7 +125,7 @@ LL | const BAD_NESTING4: pattern_type!(() is ..0) = todo!(); and 5 others error[E0308]: mismatched types - --> $DIR/nested.rs:24:43 + --> $DIR/nested.rs:23:43 | LL | const BAD_NESTING4: pattern_type!(() is ..0) = todo!(); | ^ @@ -134,7 +134,7 @@ LL | const BAD_NESTING4: pattern_type!(() is ..0) = todo!(); | arguments to this function are incorrect | help: the return type of this call is `{integer}` due to the type of the argument passed - --> $DIR/nested.rs:24:43 + --> $DIR/nested.rs:23:43 | LL | const BAD_NESTING4: pattern_type!(() is ..0) = todo!(); | ^ this argument influences the return type of `RangeSub` @@ -142,7 +142,7 @@ note: method defined here --> $SRC_DIR/core/src/pat.rs:LL:COL error[E0277]: `()` is not a valid base type for range patterns - --> $DIR/nested.rs:24:43 + --> $DIR/nested.rs:23:43 | LL | const BAD_NESTING4: pattern_type!(() is ..0) = todo!(); | ^ only integer types and `char` are supported @@ -160,7 +160,7 @@ LL | const BAD_NESTING4: pattern_type!(() is ..0) = todo!(); and 5 others error[E0277]: `f32` is not a valid base type for range patterns - --> $DIR/nested.rs:29:49 + --> $DIR/nested.rs:28:49 | LL | const BAD_NESTING5: pattern_type!(f32 is 1.0 .. 2.0) = todo!(); | ^^^ only integer types and `char` are supported diff --git a/tests/ui/type/pattern_types/non_null.rs b/tests/ui/type/pattern_types/non_null.rs index e3c634da48b8e..5ce15eb5da319 100644 --- a/tests/ui/type/pattern_types/non_null.rs +++ b/tests/ui/type/pattern_types/non_null.rs @@ -3,7 +3,7 @@ //@ normalize-stderr: "randomization_seed: \d+" -> "randomization_seed: $$SEED" //@ only-64bit -#![feature(pattern_type_macro, pattern_types, rustc_attrs)] +#![feature(pattern_types, rustc_attrs)] use std::pat::pattern_type; diff --git a/tests/ui/type/pattern_types/or_patterns.rs b/tests/ui/type/pattern_types/or_patterns.rs index d90f36983d0a0..e744025ddd673 100644 --- a/tests/ui/type/pattern_types/or_patterns.rs +++ b/tests/ui/type/pattern_types/or_patterns.rs @@ -2,13 +2,7 @@ //@ normalize-stderr: "randomization_seed: \d+" -> "randomization_seed: $$SEED" -#![feature( - pattern_type_macro, - pattern_types, - rustc_attrs, - const_trait_impl, - pattern_type_range_trait -)] +#![feature(pattern_types, rustc_attrs, const_trait_impl, pattern_type_range_trait)] use std::pat::pattern_type; diff --git a/tests/ui/type/pattern_types/or_patterns.stderr b/tests/ui/type/pattern_types/or_patterns.stderr index ab757f7405eba..bda319b4be19b 100644 --- a/tests/ui/type/pattern_types/or_patterns.stderr +++ b/tests/ui/type/pattern_types/or_patterns.stderr @@ -1,5 +1,5 @@ error[E0308]: mismatched types - --> $DIR/or_patterns.rs:26:24 + --> $DIR/or_patterns.rs:20:24 | LL | let _: NonNullI8 = 0; | --------- ^ expected `pattern_type!(i8 is (i8::MIN..=-1 | 1..))`, found integer @@ -10,31 +10,31 @@ LL | let _: NonNullI8 = 0; found type `{integer}` error[E0600]: cannot apply unary operator `-` to type `pattern_type!(i8 is (i8::MIN..=-1 | 1..))` - --> $DIR/or_patterns.rs:28:24 + --> $DIR/or_patterns.rs:22:24 | LL | let _: NonNullI8 = -1; | ^^ cannot apply unary operator `-` error[E0600]: cannot apply unary operator `-` to type `pattern_type!(i8 is (i8::MIN..=-1 | 1..))` - --> $DIR/or_patterns.rs:30:24 + --> $DIR/or_patterns.rs:24:24 | LL | let _: NonNullI8 = -128; | ^^^^ cannot apply unary operator `-` error[E0600]: cannot apply unary operator `-` to type `pattern_type!(i8 is (i8::MIN..=-2 | 0..))` - --> $DIR/or_patterns.rs:37:26 + --> $DIR/or_patterns.rs:31:26 | LL | let _: NonNegOneI8 = -1; | ^^ cannot apply unary operator `-` error[E0600]: cannot apply unary operator `-` to type `pattern_type!(i8 is (i8::MIN..=-2 | 0..))` - --> $DIR/or_patterns.rs:39:26 + --> $DIR/or_patterns.rs:33:26 | LL | let _: NonNegOneI8 = -2; | ^^ cannot apply unary operator `-` error[E0600]: cannot apply unary operator `-` to type `pattern_type!(i8 is (i8::MIN..=-2 | 0..))` - --> $DIR/or_patterns.rs:41:26 + --> $DIR/or_patterns.rs:35:26 | LL | let _: NonNegOneI8 = -128; | ^^^^ cannot apply unary operator `-` @@ -69,7 +69,7 @@ error: layout_of(pattern_type!(i8 is (i8::MIN..=-1 | 1..))) = Layout { repr_c: false, randomization_seed: $SEED, } - --> $DIR/or_patterns.rs:16:1 + --> $DIR/or_patterns.rs:10:1 | LL | type NonNullI8 = pattern_type!(i8 is ..0 | 1..); | ^^^^^^^^^^^^^^ @@ -104,7 +104,7 @@ error: layout_of(pattern_type!(i8 is (i8::MIN..=-2 | 0..))) = Layout { repr_c: false, randomization_seed: $SEED, } - --> $DIR/or_patterns.rs:20:1 + --> $DIR/or_patterns.rs:14:1 | LL | type NonNegOneI8 = pattern_type!(i8 is ..-1 | 0..); | ^^^^^^^^^^^^^^^^ diff --git a/tests/ui/type/pattern_types/or_patterns_invalid.rs b/tests/ui/type/pattern_types/or_patterns_invalid.rs index a99667c5412ce..e416d5d8ae45d 100644 --- a/tests/ui/type/pattern_types/or_patterns_invalid.rs +++ b/tests/ui/type/pattern_types/or_patterns_invalid.rs @@ -1,12 +1,6 @@ //! Demonstrate some use cases of or patterns -#![feature( - pattern_type_macro, - pattern_types, - rustc_attrs, - const_trait_impl, - pattern_type_range_trait -)] +#![feature(pattern_types, rustc_attrs, const_trait_impl, pattern_type_range_trait)] use std::pat::pattern_type; @@ -26,5 +20,5 @@ fn main() { //~? ERROR: allowed are two range patterns that are directly connected let not_simple_enough_for_mvp: pattern_type!(i8 is ..0 | 1..10 | 10..) = unsafe { std::mem::transmute(0) }; - //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types + //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types } diff --git a/tests/ui/type/pattern_types/or_patterns_invalid.stderr b/tests/ui/type/pattern_types/or_patterns_invalid.stderr index a931b76b0d0be..669721dd0bab7 100644 --- a/tests/ui/type/pattern_types/or_patterns_invalid.stderr +++ b/tests/ui/type/pattern_types/or_patterns_invalid.stderr @@ -1,7 +1,7 @@ error: only non-overlapping pattern type ranges are allowed at present error[E0512]: cannot transmute between types of different sizes, or dependently-sized types - --> $DIR/or_patterns_invalid.rs:15:69 + --> $DIR/or_patterns_invalid.rs:9:69 | LL | let not_adjacent: pattern_type!(i8 is -127..0 | 1..) = unsafe { std::mem::transmute(0) }; | ^^^^^^^^^^^^^^^^^^^ @@ -12,7 +12,7 @@ LL | let not_adjacent: pattern_type!(i8 is -127..0 | 1..) = unsafe { std::me error: one pattern needs to end at `i8::MAX`, but was 29 instead error[E0512]: cannot transmute between types of different sizes, or dependently-sized types - --> $DIR/or_patterns_invalid.rs:19:71 + --> $DIR/or_patterns_invalid.rs:13:71 | LL | let not_wrapping: pattern_type!(i8 is 10..20 | 20..30) = unsafe { std::mem::transmute(0) }; | ^^^^^^^^^^^^^^^^^^^ @@ -23,7 +23,7 @@ LL | let not_wrapping: pattern_type!(i8 is 10..20 | 20..30) = unsafe { std:: error: only signed integer base types are allowed for or-pattern pattern types at present error[E0512]: cannot transmute between types of different sizes, or dependently-sized types - --> $DIR/or_patterns_invalid.rs:23:65 + --> $DIR/or_patterns_invalid.rs:17:65 | LL | let not_signed: pattern_type!(u8 is 10.. | 0..5) = unsafe { std::mem::transmute(0) }; | ^^^^^^^^^^^^^^^^^^^ @@ -34,7 +34,7 @@ LL | let not_signed: pattern_type!(u8 is 10.. | 0..5) = unsafe { std::mem::t error: the only or-pattern types allowed are two range patterns that are directly connected at their overflow site error[E0512]: cannot transmute between types of different sizes, or dependently-sized types - --> $DIR/or_patterns_invalid.rs:28:18 + --> $DIR/or_patterns_invalid.rs:22:18 | LL | unsafe { std::mem::transmute(0) }; | ^^^^^^^^^^^^^^^^^^^ diff --git a/tests/ui/type/pattern_types/pattern_type_mismatch.rs b/tests/ui/type/pattern_types/pattern_type_mismatch.rs index 0c88f27d83686..30c368033b099 100644 --- a/tests/ui/type/pattern_types/pattern_type_mismatch.rs +++ b/tests/ui/type/pattern_types/pattern_type_mismatch.rs @@ -1,7 +1,6 @@ //! Check that pattern types patterns must be of the type of the base type #![feature(pattern_types)] -#![feature(pattern_type_macro)] use std::pat::pattern_type; diff --git a/tests/ui/type/pattern_types/pattern_type_mismatch.stderr b/tests/ui/type/pattern_types/pattern_type_mismatch.stderr index 129e4b5cdc7be..bfbee74897a1b 100644 --- a/tests/ui/type/pattern_types/pattern_type_mismatch.stderr +++ b/tests/ui/type/pattern_types/pattern_type_mismatch.stderr @@ -1,5 +1,5 @@ error[E0308]: mismatched types - --> $DIR/pattern_type_mismatch.rs:8:41 + --> $DIR/pattern_type_mismatch.rs:7:41 | LL | const BAD_NESTING4: pattern_type!(u8 is 'a'..='a') = todo!(); | -- ^^^ expected `u8`, found `char` @@ -12,7 +12,7 @@ LL | const BAD_NESTING4: pattern_type!(u8 is b'a'..='a') = todo!(); | + error[E0308]: mismatched types - --> $DIR/pattern_type_mismatch.rs:8:47 + --> $DIR/pattern_type_mismatch.rs:7:47 | LL | const BAD_NESTING4: pattern_type!(u8 is 'a'..='a') = todo!(); | -- ^^^ expected `u8`, found `char` @@ -25,7 +25,7 @@ LL | const BAD_NESTING4: pattern_type!(u8 is 'a'..=b'a') = todo!(); | + error[E0308]: mismatched types - --> $DIR/pattern_type_mismatch.rs:12:43 + --> $DIR/pattern_type_mismatch.rs:11:43 | LL | const BAD_NESTING5: pattern_type!(char is 1..=1) = todo!(); | ---- ^ expected `char`, found `u8` @@ -33,7 +33,7 @@ LL | const BAD_NESTING5: pattern_type!(char is 1..=1) = todo!(); | the pattern must match the type error[E0308]: mismatched types - --> $DIR/pattern_type_mismatch.rs:12:47 + --> $DIR/pattern_type_mismatch.rs:11:47 | LL | const BAD_NESTING5: pattern_type!(char is 1..=1) = todo!(); | ---- ^ expected `char`, found `u8` diff --git a/tests/ui/type/pattern_types/range_patterns.rs b/tests/ui/type/pattern_types/range_patterns.rs index 1ad6469967cbc..5edf357299c98 100644 --- a/tests/ui/type/pattern_types/range_patterns.rs +++ b/tests/ui/type/pattern_types/range_patterns.rs @@ -1,6 +1,4 @@ #![feature(pattern_types, rustc_attrs, const_trait_impl, pattern_type_range_trait)] -#![feature(pattern_type_macro)] -#![allow(incomplete_features)] //@ normalize-stderr: "randomization_seed: \d+" -> "randomization_seed: $$SEED" diff --git a/tests/ui/type/pattern_types/range_patterns.stderr b/tests/ui/type/pattern_types/range_patterns.stderr index a1e085ffe44ff..5ed826fa66331 100644 --- a/tests/ui/type/pattern_types/range_patterns.stderr +++ b/tests/ui/type/pattern_types/range_patterns.stderr @@ -28,7 +28,7 @@ error: layout_of(NonZero) = Layout { repr_c: false, randomization_seed: $SEED, } - --> $DIR/range_patterns.rs:10:1 + --> $DIR/range_patterns.rs:8:1 | LL | type X = std::num::NonZeroU32; | ^^^^^^ @@ -63,7 +63,7 @@ error: layout_of(pattern_type!(u32 is 1..)) = Layout { repr_c: false, randomization_seed: $SEED, } - --> $DIR/range_patterns.rs:12:1 + --> $DIR/range_patterns.rs:10:1 | LL | type Y = pattern_type!(u32 is 1..); | ^^^^^^ @@ -130,7 +130,7 @@ error: layout_of(Option) = Layout { repr_c: false, randomization_seed: $SEED, } - --> $DIR/range_patterns.rs:14:1 + --> $DIR/range_patterns.rs:12:1 | LL | type Z = Option; | ^^^^^^ @@ -197,7 +197,7 @@ error: layout_of(Option>) = Layout { repr_c: false, randomization_seed: $SEED, } - --> $DIR/range_patterns.rs:16:1 + --> $DIR/range_patterns.rs:14:1 | LL | type A = Option; | ^^^^^^ @@ -232,7 +232,7 @@ error: layout_of(NonZeroU32New) = Layout { repr_c: false, randomization_seed: $SEED, } - --> $DIR/range_patterns.rs:18:1 + --> $DIR/range_patterns.rs:16:1 | LL | struct NonZeroU32New(pattern_type!(u32 is 1..)); | ^^^^^^^^^^^^^^^^^^^^ @@ -240,19 +240,19 @@ LL | struct NonZeroU32New(pattern_type!(u32 is 1..)); error: pattern type ranges cannot wrap: 1..=0 error: the type has an unknown layout - --> $DIR/range_patterns.rs:21:1 + --> $DIR/range_patterns.rs:19:1 | LL | type EMPTY = pattern_type!(u32 is 1..1); | ^^^^^^^^^^ error[E0080]: evaluation panicked: exclusive range end at minimum value of type - --> $DIR/range_patterns.rs:24:37 + --> $DIR/range_patterns.rs:22:37 | LL | type WRAP = pattern_type!(u32 is 1..0); | ^ evaluation of `WRAP::{constant#1}` failed here error: the type has an unknown layout - --> $DIR/range_patterns.rs:24:1 + --> $DIR/range_patterns.rs:22:1 | LL | type WRAP = pattern_type!(u32 is 1..0); | ^^^^^^^^^ @@ -260,7 +260,7 @@ LL | type WRAP = pattern_type!(u32 is 1..0); error: pattern type ranges cannot wrap: 5..=1 error: the type has an unknown layout - --> $DIR/range_patterns.rs:28:1 + --> $DIR/range_patterns.rs:26:1 | LL | type WRAP2 = pattern_type!(u32 is 5..2); | ^^^^^^^^^^ @@ -295,7 +295,7 @@ error: layout_of(pattern_type!(i8 is -10..=10)) = Layout { repr_c: false, randomization_seed: $SEED, } - --> $DIR/range_patterns.rs:31:1 + --> $DIR/range_patterns.rs:29:1 | LL | type SIGN = pattern_type!(i8 is -10..=10); | ^^^^^^^^^ @@ -330,7 +330,7 @@ error: layout_of(pattern_type!(i8 is i8::MIN..=0)) = Layout { repr_c: false, randomization_seed: $SEED, } - --> $DIR/range_patterns.rs:34:1 + --> $DIR/range_patterns.rs:32:1 | LL | type MIN = pattern_type!(i8 is -128..=0); | ^^^^^^^^ @@ -338,7 +338,7 @@ LL | type MIN = pattern_type!(i8 is -128..=0); error: pattern type ranges cannot wrap: 120..=-120 error: the type has an unknown layout - --> $DIR/range_patterns.rs:37:1 + --> $DIR/range_patterns.rs:35:1 | LL | type SignedWrap = pattern_type!(i8 is 120..=-120); | ^^^^^^^^^^^^^^^ diff --git a/tests/ui/type/pattern_types/range_patterns_inherent_impls.rs b/tests/ui/type/pattern_types/range_patterns_inherent_impls.rs index fe8feda0934e2..14107463511f3 100644 --- a/tests/ui/type/pattern_types/range_patterns_inherent_impls.rs +++ b/tests/ui/type/pattern_types/range_patterns_inherent_impls.rs @@ -1,6 +1,4 @@ #![feature(pattern_types, rustc_attrs)] -#![feature(pattern_type_macro)] -#![allow(incomplete_features)] //! check that pattern types can have traits implemented for them if //! their base type is a local type. diff --git a/tests/ui/type/pattern_types/range_patterns_inherent_impls.stderr b/tests/ui/type/pattern_types/range_patterns_inherent_impls.stderr index ed2e4c0bd5f8c..f01510557588c 100644 --- a/tests/ui/type/pattern_types/range_patterns_inherent_impls.stderr +++ b/tests/ui/type/pattern_types/range_patterns_inherent_impls.stderr @@ -1,12 +1,12 @@ error[E0390]: cannot define inherent `impl` for primitive types outside of `core` - --> $DIR/range_patterns_inherent_impls.rs:12:1 + --> $DIR/range_patterns_inherent_impls.rs:10:1 | LL | impl Y { | ^^^^^^ | = help: consider moving this inherent impl into `core` if possible help: alternatively add `#[rustc_allow_incoherent_impl]` to the relevant impl items - --> $DIR/range_patterns_inherent_impls.rs:14:5 + --> $DIR/range_patterns_inherent_impls.rs:12:5 | LL | fn foo() {} | ^^^^^^^^ diff --git a/tests/ui/type/pattern_types/range_patterns_trait_impls.rs b/tests/ui/type/pattern_types/range_patterns_trait_impls.rs index 1731cd470fe2c..e7c5479e43d0c 100644 --- a/tests/ui/type/pattern_types/range_patterns_trait_impls.rs +++ b/tests/ui/type/pattern_types/range_patterns_trait_impls.rs @@ -1,6 +1,4 @@ #![feature(pattern_types, rustc_attrs)] -#![feature(pattern_type_macro)] -#![allow(incomplete_features)] //! check that pattern types can have local traits //! implemented for them. diff --git a/tests/ui/type/pattern_types/range_patterns_trait_impls2.rs b/tests/ui/type/pattern_types/range_patterns_trait_impls2.rs index 90f80a2f34645..d367bd174f3ef 100644 --- a/tests/ui/type/pattern_types/range_patterns_trait_impls2.rs +++ b/tests/ui/type/pattern_types/range_patterns_trait_impls2.rs @@ -1,6 +1,4 @@ #![feature(pattern_types, rustc_attrs)] -#![feature(pattern_type_macro)] -#![allow(incomplete_features)] //! check that pattern types can have local traits //! implemented for them. diff --git a/tests/ui/type/pattern_types/range_patterns_trait_impls2.stderr b/tests/ui/type/pattern_types/range_patterns_trait_impls2.stderr index 4517c7e910f4e..2f372751277a2 100644 --- a/tests/ui/type/pattern_types/range_patterns_trait_impls2.stderr +++ b/tests/ui/type/pattern_types/range_patterns_trait_impls2.stderr @@ -1,5 +1,5 @@ error[E0117]: only traits defined in the current crate can be implemented for arbitrary types - --> $DIR/range_patterns_trait_impls2.rs:12:1 + --> $DIR/range_patterns_trait_impls2.rs:10:1 | LL | impl Eq for Y {} | ^^^^^^^^^^^^- diff --git a/tests/ui/type/pattern_types/range_patterns_unusable.rs b/tests/ui/type/pattern_types/range_patterns_unusable.rs index 98f13ca0bc0bb..d023541d12e48 100644 --- a/tests/ui/type/pattern_types/range_patterns_unusable.rs +++ b/tests/ui/type/pattern_types/range_patterns_unusable.rs @@ -1,6 +1,4 @@ #![feature(pattern_types, rustc_attrs)] -#![feature(pattern_type_macro)] -#![allow(incomplete_features)] //! Some practical niche checks. diff --git a/tests/ui/type/pattern_types/range_patterns_unusable.stderr b/tests/ui/type/pattern_types/range_patterns_unusable.stderr index 5c61f6347bbfc..15e83bfad5228 100644 --- a/tests/ui/type/pattern_types/range_patterns_unusable.stderr +++ b/tests/ui/type/pattern_types/range_patterns_unusable.stderr @@ -1,5 +1,5 @@ error[E0512]: cannot transmute between types of different sizes, or dependently-sized types - --> $DIR/range_patterns_unusable.rs:13:35 + --> $DIR/range_patterns_unusable.rs:11:35 | LL | let _: Option = unsafe { std::mem::transmute(z) }; | ^^^^^^^^^^^^^^^^^^^ diff --git a/tests/ui/type/pattern_types/range_patterns_unusable_math.rs b/tests/ui/type/pattern_types/range_patterns_unusable_math.rs index 71becd28d1cac..f44ac1e7be392 100644 --- a/tests/ui/type/pattern_types/range_patterns_unusable_math.rs +++ b/tests/ui/type/pattern_types/range_patterns_unusable_math.rs @@ -1,6 +1,4 @@ #![feature(pattern_types, rustc_attrs)] -#![feature(pattern_type_macro)] -#![allow(incomplete_features)] //! check that pattern types don't have an `Add` impl. diff --git a/tests/ui/type/pattern_types/range_patterns_unusable_math.stderr b/tests/ui/type/pattern_types/range_patterns_unusable_math.stderr index b55031dc3cf8b..5dab944cfe2de 100644 --- a/tests/ui/type/pattern_types/range_patterns_unusable_math.stderr +++ b/tests/ui/type/pattern_types/range_patterns_unusable_math.stderr @@ -1,5 +1,5 @@ error[E0369]: cannot add `u32` to `pattern_type!(u32 is 1..)` - --> $DIR/range_patterns_unusable_math.rs:14:15 + --> $DIR/range_patterns_unusable_math.rs:12:15 | LL | let x = x + 1_u32; | - ^ ----- u32 diff --git a/tests/ui/type/pattern_types/range_patterns_usage.rs b/tests/ui/type/pattern_types/range_patterns_usage.rs index 0ecbdcaa0f7a3..5d09785e8faa8 100644 --- a/tests/ui/type/pattern_types/range_patterns_usage.rs +++ b/tests/ui/type/pattern_types/range_patterns_usage.rs @@ -1,6 +1,4 @@ #![feature(pattern_types, rustc_attrs)] -#![feature(pattern_type_macro)] -#![allow(incomplete_features)] //@ check-pass //! check that pattern types can actually be part of code that compiles successfully. diff --git a/tests/ui/type/pattern_types/reverse_range.rs b/tests/ui/type/pattern_types/reverse_range.rs index 34c931e4e965a..8d0fd8ca1b628 100644 --- a/tests/ui/type/pattern_types/reverse_range.rs +++ b/tests/ui/type/pattern_types/reverse_range.rs @@ -1,6 +1,5 @@ //! Check that the range start must be smaller than the range end #![feature(pattern_types, const_trait_impl, pattern_type_range_trait)] -#![feature(pattern_type_macro)] use std::pat::pattern_type; diff --git a/tests/ui/type/pattern_types/reverse_range.stderr b/tests/ui/type/pattern_types/reverse_range.stderr index 6e6e34409a39e..bcaf19790ba38 100644 --- a/tests/ui/type/pattern_types/reverse_range.stderr +++ b/tests/ui/type/pattern_types/reverse_range.stderr @@ -1,5 +1,5 @@ error[E0080]: evaluation panicked: exclusive range end at minimum value of type - --> $DIR/reverse_range.rs:7:36 + --> $DIR/reverse_range.rs:6:36 | LL | const NONE: pattern_type!(u8 is 1..0) = unsafe { std::mem::transmute(3_u8) }; | ^ evaluation of `NONE::{constant#1}` failed here diff --git a/tests/ui/type/pattern_types/signed_ranges.rs b/tests/ui/type/pattern_types/signed_ranges.rs index 3725fbda7292a..e18c0299cbba6 100644 --- a/tests/ui/type/pattern_types/signed_ranges.rs +++ b/tests/ui/type/pattern_types/signed_ranges.rs @@ -1,5 +1,4 @@ #![feature(pattern_types)] -#![feature(pattern_type_macro)] use std::pat::pattern_type; diff --git a/tests/ui/type/pattern_types/signed_ranges.stderr b/tests/ui/type/pattern_types/signed_ranges.stderr index 79bf8501b639f..66df48363af65 100644 --- a/tests/ui/type/pattern_types/signed_ranges.stderr +++ b/tests/ui/type/pattern_types/signed_ranges.stderr @@ -1,5 +1,5 @@ error[E0277]: the trait bound `u8: Neg` is not satisfied - --> $DIR/signed_ranges.rs:14:9 + --> $DIR/signed_ranges.rs:13:9 | LL | -10..253 => {} | ^^^ the trait `Neg` is not implemented for `u8` @@ -16,13 +16,13 @@ LL | -10..253 => {} and 12 others error[E0277]: the trait bound `char: Neg` is not satisfied - --> $DIR/signed_ranges.rs:20:9 + --> $DIR/signed_ranges.rs:19:9 | LL | -'\0'..'a' => {} | ^^^^^ the trait `Neg` is not implemented for `char` error[E0600]: cannot apply unary operator `-` to type `u32` - --> $DIR/signed_ranges.rs:6:34 + --> $DIR/signed_ranges.rs:5:34 | LL | type Sign = pattern_type!(u32 is -10..); | ^^^ cannot apply unary operator `-` @@ -30,7 +30,7 @@ LL | type Sign = pattern_type!(u32 is -10..); = note: unsigned values cannot be negated error[E0600]: cannot apply unary operator `-` to type `char` - --> $DIR/signed_ranges.rs:9:41 + --> $DIR/signed_ranges.rs:8:41 | LL | type SignedChar = pattern_type!(char is -'A'..); | ^^^^ cannot apply unary operator `-` diff --git a/tests/ui/type/pattern_types/transmute.rs b/tests/ui/type/pattern_types/transmute.rs index 4e686245f9375..77f99253543ca 100644 --- a/tests/ui/type/pattern_types/transmute.rs +++ b/tests/ui/type/pattern_types/transmute.rs @@ -1,7 +1,7 @@ //@ revisions: current next //@ ignore-compare-mode-next-solver (explicit revisions) //@[next] compile-flags: -Znext-solver -#![feature(pattern_types, pattern_type_macro, generic_pattern_types)] +#![feature(pattern_types, generic_pattern_types)] #![expect(incomplete_features)] use std::pat::pattern_type; diff --git a/tests/ui/type/pattern_types/unimplemented_pat.rs b/tests/ui/type/pattern_types/unimplemented_pat.rs index 44851ec1a1049..7e57e1f7ff8d6 100644 --- a/tests/ui/type/pattern_types/unimplemented_pat.rs +++ b/tests/ui/type/pattern_types/unimplemented_pat.rs @@ -1,7 +1,7 @@ //! This test ensures we do not ICE for unimplemented //! patterns even if the feature gate is enabled. -#![feature(pattern_type_macro, pattern_types)] +#![feature(pattern_types)] use std::pat::pattern_type; diff --git a/tests/ui/type/pattern_types/unsize.rs b/tests/ui/type/pattern_types/unsize.rs index 1020dd8c21544..18d9a52a9195e 100644 --- a/tests/ui/type/pattern_types/unsize.rs +++ b/tests/ui/type/pattern_types/unsize.rs @@ -2,7 +2,7 @@ //@ check-pass -#![feature(pattern_type_macro, pattern_types)] +#![feature(pattern_types)] use std::pat::pattern_type; diff --git a/tests/ui/type/pattern_types/validity.rs b/tests/ui/type/pattern_types/validity.rs index f4c62dc6712e9..cbabe06c312ce 100644 --- a/tests/ui/type/pattern_types/validity.rs +++ b/tests/ui/type/pattern_types/validity.rs @@ -3,7 +3,6 @@ //@ normalize-stderr: "([[:xdigit:]]{2}\s){4,8}\s+│\s.{4,8}" -> "HEX_DUMP" #![feature(pattern_types, const_trait_impl, pattern_type_range_trait)] -#![feature(pattern_type_macro)] use std::pat::pattern_type; diff --git a/tests/ui/type/pattern_types/validity.stderr b/tests/ui/type/pattern_types/validity.stderr index 7cfa6b3400a41..9ddc07ce89cee 100644 --- a/tests/ui/type/pattern_types/validity.stderr +++ b/tests/ui/type/pattern_types/validity.stderr @@ -1,5 +1,5 @@ error[E0080]: constructing invalid value of type pattern_type!(u32 is 1..): encountered 0, but expected something greater or equal to 1 - --> $DIR/validity.rs:10:1 + --> $DIR/validity.rs:9:1 | LL | const BAD: pattern_type!(u32 is 1..) = unsafe { std::mem::transmute(0) }; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value @@ -10,7 +10,7 @@ LL | const BAD: pattern_type!(u32 is 1..) = unsafe { std::mem::transmute(0) }; } error[E0080]: reading memory at ALLOC$ID[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory - --> $DIR/validity.rs:13:1 + --> $DIR/validity.rs:12:1 | LL | const BAD_UNINIT: pattern_type!(u32 is 1..) = | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `BAD_UNINIT` failed here @@ -20,7 +20,7 @@ LL | const BAD_UNINIT: pattern_type!(u32 is 1..) = } error[E0080]: unable to turn pointer into integer - --> $DIR/validity.rs:17:1 + --> $DIR/validity.rs:16:1 | LL | const BAD_PTR: pattern_type!(usize is 1..) = unsafe { std::mem::transmute(&42) }; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `BAD_PTR` failed here @@ -29,7 +29,7 @@ LL | const BAD_PTR: pattern_type!(usize is 1..) = unsafe { std::mem::transmute(& = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported error[E0080]: constructing invalid value of type (pattern_type!(u32 is 1..), u32): at .0, encountered 0, but expected something greater or equal to 1 - --> $DIR/validity.rs:20:1 + --> $DIR/validity.rs:19:1 | LL | const BAD_AGGREGATE: (pattern_type!(u32 is 1..), u32) = (unsafe { std::mem::transmute(0) }, 0); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value @@ -40,7 +40,7 @@ LL | const BAD_AGGREGATE: (pattern_type!(u32 is 1..), u32) = (unsafe { std::mem: } error[E0080]: constructing invalid value of type Foo: at .0.0, encountered 0, but expected something greater or equal to 1 - --> $DIR/validity.rs:26:1 + --> $DIR/validity.rs:25:1 | LL | const BAD_FOO: Foo = Foo(Bar(unsafe { std::mem::transmute(0) })); | ^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value @@ -51,7 +51,7 @@ LL | const BAD_FOO: Foo = Foo(Bar(unsafe { std::mem::transmute(0) })); } error[E0080]: reading memory at ALLOC$ID[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory - --> $DIR/validity.rs:29:1 + --> $DIR/validity.rs:28:1 | LL | const CHAR_UNINIT: pattern_type!(char is 'A'..'Z') = | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `CHAR_UNINIT` failed here @@ -61,7 +61,7 @@ LL | const CHAR_UNINIT: pattern_type!(char is 'A'..'Z') = } error[E0080]: constructing invalid value of type pattern_type!(char is 'A'..='Y'): encountered 97, but expected something in the range 65..=89 - --> $DIR/validity.rs:33:1 + --> $DIR/validity.rs:32:1 | LL | const CHAR_OOB_PAT: pattern_type!(char is 'A'..'Z') = unsafe { std::mem::transmute('a') }; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value @@ -72,7 +72,7 @@ LL | const CHAR_OOB_PAT: pattern_type!(char is 'A'..'Z') = unsafe { std::mem::tr } error[E0080]: constructing invalid value of type pattern_type!(char is 'A'..='Y'): encountered 0xffffffff, but expected a valid unicode scalar value (in `0..=0x10FFFF` but not in `0xD800..=0xDFFF`) - --> $DIR/validity.rs:36:1 + --> $DIR/validity.rs:35:1 | LL | const CHAR_OOB: pattern_type!(char is 'A'..'Z') = unsafe { std::mem::transmute(u32::MAX) }; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value diff --git a/tests/ui/unpretty/exhaustive.expanded.stdout b/tests/ui/unpretty/exhaustive.expanded.stdout index 3551d40dffbfc..0bd7aca6a007b 100644 --- a/tests/ui/unpretty/exhaustive.expanded.stdout +++ b/tests/ui/unpretty/exhaustive.expanded.stdout @@ -21,7 +21,6 @@ #![feature(more_qualified_paths)] #![feature(never_patterns)] #![feature(pattern_types)] -#![feature(pattern_type_macro)] #![feature(prelude_import)] #![feature(specialization)] #![feature(trace_macros)] @@ -632,7 +631,7 @@ mod types { /*! FIXME: todo */ } /// TyKind::Pat - fn ty_pat() { let _: u32 is const 1..; } + fn ty_pat() { let _: k#pattern_type(u32 is const 1..); } } mod visibilities { /// VisibilityKind::Public diff --git a/tests/ui/unpretty/exhaustive.hir.stderr b/tests/ui/unpretty/exhaustive.hir.stderr index 276bc5b5d2573..5ca4b080a95e5 100644 --- a/tests/ui/unpretty/exhaustive.hir.stderr +++ b/tests/ui/unpretty/exhaustive.hir.stderr @@ -1,17 +1,17 @@ error[E0697]: closures cannot be static - --> $DIR/exhaustive.rs:210:9 + --> $DIR/exhaustive.rs:209:9 | LL | static || value; | ^^^^^^^^^ error[E0697]: closures cannot be static - --> $DIR/exhaustive.rs:211:9 + --> $DIR/exhaustive.rs:210:9 | LL | static move || value; | ^^^^^^^^^^^^^^ error[E0728]: `await` is only allowed inside `async` functions and blocks - --> $DIR/exhaustive.rs:240:13 + --> $DIR/exhaustive.rs:239:13 | LL | fn expr_await() { | --------------- this is not `async` @@ -20,19 +20,19 @@ LL | fut.await; | ^^^^^ only allowed inside `async` functions and blocks error: in expressions, `_` can only be used on the left-hand side of an assignment - --> $DIR/exhaustive.rs:291:9 + --> $DIR/exhaustive.rs:290:9 | LL | _; | ^ `_` not allowed here error[E0214]: parenthesized type parameters may only be used with a `Fn` trait - --> $DIR/exhaustive.rs:301:9 + --> $DIR/exhaustive.rs:300:9 | LL | x::(); | ^^^^^ only `Fn` traits may use parentheses error[E0214]: parenthesized type parameters may only be used with a `Fn` trait - --> $DIR/exhaustive.rs:302:9 + --> $DIR/exhaustive.rs:301:9 | LL | x::(T, T) -> T; | ^^^^^^^^^^^^^^ only `Fn` traits may use parentheses @@ -44,31 +44,31 @@ LL + x:: -> T; | error[E0214]: parenthesized type parameters may only be used with a `Fn` trait - --> $DIR/exhaustive.rs:303:9 + --> $DIR/exhaustive.rs:302:9 | LL | crate::() -> ()::expressions::() -> ()::expr_path; | ^^^^^^^^^^^^^^^ only `Fn` traits may use parentheses error[E0214]: parenthesized type parameters may only be used with a `Fn` trait - --> $DIR/exhaustive.rs:303:26 + --> $DIR/exhaustive.rs:302:26 | LL | crate::() -> ()::expressions::() -> ()::expr_path; | ^^^^^^^^^^^^^^^^^^^^^ only `Fn` traits may use parentheses error[E0214]: parenthesized type parameters may only be used with a `Fn` trait - --> $DIR/exhaustive.rs:306:9 + --> $DIR/exhaustive.rs:305:9 | LL | core::()::marker::()::PhantomData; | ^^^^^^^^ only `Fn` traits may use parentheses error[E0214]: parenthesized type parameters may only be used with a `Fn` trait - --> $DIR/exhaustive.rs:306:19 + --> $DIR/exhaustive.rs:305:19 | LL | core::()::marker::()::PhantomData; | ^^^^^^^^^^ only `Fn` traits may use parentheses error: `yield` can only be used in `#[coroutine]` closures, or `gen` blocks - --> $DIR/exhaustive.rs:393:9 + --> $DIR/exhaustive.rs:392:9 | LL | yield; | ^^^^^ @@ -79,7 +79,7 @@ LL | #[coroutine] fn expr_yield() { | ++++++++++++ error[E0703]: invalid ABI: found `C++` - --> $DIR/exhaustive.rs:473:23 + --> $DIR/exhaustive.rs:472:23 | LL | unsafe extern "C++" {} | ^^^^^ invalid ABI @@ -87,7 +87,7 @@ LL | unsafe extern "C++" {} = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions error: `..` patterns are not allowed here - --> $DIR/exhaustive.rs:675:13 + --> $DIR/exhaustive.rs:674:13 | LL | let ..; | ^^ @@ -95,13 +95,13 @@ LL | let ..; = note: only allowed in tuple, tuple struct, and slice patterns error[E0214]: parenthesized type parameters may only be used with a `Fn` trait - --> $DIR/exhaustive.rs:790:16 + --> $DIR/exhaustive.rs:789:16 | LL | let _: T() -> !; | ^^^^^^^^ only `Fn` traits may use parentheses error[E0562]: `impl Trait` is not allowed in the type of variable bindings - --> $DIR/exhaustive.rs:804:16 + --> $DIR/exhaustive.rs:803:16 | LL | let _: impl Send; | ^^^^^^^^^ @@ -112,7 +112,7 @@ LL | let _: impl Send; = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date error[E0562]: `impl Trait` is not allowed in the type of variable bindings - --> $DIR/exhaustive.rs:805:16 + --> $DIR/exhaustive.rs:804:16 | LL | let _: impl Send + 'static; | ^^^^^^^^^^^^^^^^^^^ @@ -123,7 +123,7 @@ LL | let _: impl Send + 'static; = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date error[E0562]: `impl Trait` is not allowed in the type of variable bindings - --> $DIR/exhaustive.rs:806:16 + --> $DIR/exhaustive.rs:805:16 | LL | let _: impl 'static + Send; | ^^^^^^^^^^^^^^^^^^^ @@ -134,7 +134,7 @@ LL | let _: impl 'static + Send; = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date error[E0562]: `impl Trait` is not allowed in the type of variable bindings - --> $DIR/exhaustive.rs:807:16 + --> $DIR/exhaustive.rs:806:16 | LL | let _: impl ?Sized; | ^^^^^^^^^^^ @@ -145,7 +145,7 @@ LL | let _: impl ?Sized; = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date error[E0562]: `impl Trait` is not allowed in the type of variable bindings - --> $DIR/exhaustive.rs:808:16 + --> $DIR/exhaustive.rs:807:16 | LL | let _: impl [const] Clone; | ^^^^^^^^^^^^^^^^^^ @@ -156,7 +156,7 @@ LL | let _: impl [const] Clone; = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date error[E0562]: `impl Trait` is not allowed in the type of variable bindings - --> $DIR/exhaustive.rs:809:16 + --> $DIR/exhaustive.rs:808:16 | LL | let _: impl for<'a> Send; | ^^^^^^^^^^^^^^^^^ diff --git a/tests/ui/unpretty/exhaustive.hir.stdout b/tests/ui/unpretty/exhaustive.hir.stdout index 6af4d3b5b81de..4726e9aa762e7 100644 --- a/tests/ui/unpretty/exhaustive.hir.stdout +++ b/tests/ui/unpretty/exhaustive.hir.stdout @@ -1,9 +1,8 @@ #![attr = Feature([auto_traits#0, internal_syntax#0, const_trait_impl#0, coroutines#0, decl_macro#0, deref_patterns#0, explicit_tail_calls#0, forced_keywords#0, gen_blocks#0, more_qualified_paths#0, never_patterns#0, -pattern_types#0, pattern_type_macro#0, prelude_import#0, specialization#0, -trace_macros#0, trait_alias#0, try_blocks#0, try_blocks_heterogeneous#0, -yeet_expr#0])] +pattern_types#0, prelude_import#0, specialization#0, trace_macros#0, +trait_alias#0, try_blocks#0, try_blocks_heterogeneous#0, yeet_expr#0])] #![attr = LintCheck([LintCheck {lint_name: LintName { tool: None, name: "incomplete_features" }, kind: Allow}, LintCheck {lint_name: LintName { tool: None, name: "unused_attributes" }, diff --git a/tests/ui/unpretty/exhaustive.rs b/tests/ui/unpretty/exhaustive.rs index 15f684fc3dd72..36cc724351a64 100644 --- a/tests/ui/unpretty/exhaustive.rs +++ b/tests/ui/unpretty/exhaustive.rs @@ -20,7 +20,6 @@ #![feature(more_qualified_paths)] #![feature(never_patterns)] #![feature(pattern_types)] -#![feature(pattern_type_macro)] #![feature(prelude_import)] #![feature(specialization)] #![feature(trace_macros)] @@ -846,7 +845,7 @@ mod types { /// TyKind::Pat fn ty_pat() { - let _: core::pattern_type!(u32 is 1..); + let _: pattern_type!(u32 is 1..); } } diff --git a/tests/ui/view-types/auxiliary/hygiene.rs b/tests/ui/view-types/auxiliary/hygiene.rs index cf842b56e6970..3b022299733c9 100644 --- a/tests/ui/view-types/auxiliary/hygiene.rs +++ b/tests/ui/view-types/auxiliary/hygiene.rs @@ -1,6 +1,6 @@ //@ edition:2015 -#![feature(view_types, view_type_macro)] +#![feature(view_types)] pub use std::view::view_type; diff --git a/tests/ui/view-types/duplicate_field.rs b/tests/ui/view-types/duplicate_field.rs index b45580510b6cb..4b3e0ca0850e0 100644 --- a/tests/ui/view-types/duplicate_field.rs +++ b/tests/ui/view-types/duplicate_field.rs @@ -1,5 +1,4 @@ -#![feature(view_types, view_type_macro)] -#![allow(unused)] +#![feature(view_types)] use std::view::view_type; diff --git a/tests/ui/view-types/duplicate_field.stderr b/tests/ui/view-types/duplicate_field.stderr index f0162f6e0a67d..c974b0ead238a 100644 --- a/tests/ui/view-types/duplicate_field.stderr +++ b/tests/ui/view-types/duplicate_field.stderr @@ -1,5 +1,5 @@ error: field `bar` is already part of the view - --> $DIR/duplicate_field.rs:13:38 + --> $DIR/duplicate_field.rs:12:38 | LL | _foo: &mut view_type!(Foo.{ bar, bar }), | --- ^^^ @@ -7,7 +7,7 @@ LL | _foo: &mut view_type!(Foo.{ bar, bar }), | field `bar` is declared as viewed here error: field `0` is already part of the view - --> $DIR/duplicate_field.rs:15:38 + --> $DIR/duplicate_field.rs:14:38 | LL | _pair: &mut view_type!(Pair.{ 0, 0 }), | - ^ @@ -15,7 +15,7 @@ LL | _pair: &mut view_type!(Pair.{ 0, 0 }), | field `0` is declared as viewed here error: field `bar` is already part of the view - --> $DIR/duplicate_field.rs:21:44 + --> $DIR/duplicate_field.rs:20:44 | LL | fn f(self: &mut view_type!(Self.{ bar, bar })) {} | --- ^^^ @@ -23,7 +23,7 @@ LL | fn f(self: &mut view_type!(Self.{ bar, bar })) {} | field `bar` is declared as viewed here error: field `0` is already part of the view - --> $DIR/duplicate_field.rs:26:42 + --> $DIR/duplicate_field.rs:25:42 | LL | fn f(self: &mut view_type!(Self.{ 0, 0 })) {} | - ^ diff --git a/tests/ui/view-types/feature-gate-view-types.rs b/tests/ui/view-types/feature-gate-view-types.rs index 961f96e18bb99..d30c737c130c7 100644 --- a/tests/ui/view-types/feature-gate-view-types.rs +++ b/tests/ui/view-types/feature-gate-view-types.rs @@ -8,6 +8,6 @@ struct Foo { } type FooBar = view_type!(Foo.{ bar }); -//~^ ERROR use of unstable library feature `view_type_macro` +//~^ ERROR use of unstable library feature `view_types` type FooBaz = view_type!(Foo.{ baz }); -//~^ ERROR use of unstable library feature `view_type_macro` +//~^ ERROR use of unstable library feature `view_types` diff --git a/tests/ui/view-types/feature-gate-view-types.stderr b/tests/ui/view-types/feature-gate-view-types.stderr index 407bf343ca13b..bda3aebf2b744 100644 --- a/tests/ui/view-types/feature-gate-view-types.stderr +++ b/tests/ui/view-types/feature-gate-view-types.stderr @@ -1,21 +1,21 @@ -error[E0658]: use of unstable library feature `view_type_macro` +error[E0658]: use of unstable library feature `view_types` --> $DIR/feature-gate-view-types.rs:10:15 | LL | type FooBar = view_type!(Foo.{ bar }); | ^^^^^^^^^ | = note: see issue #155938 for more information - = help: add `#![feature(view_type_macro)]` to the crate attributes to enable + = help: add `#![feature(view_types)]` to the crate attributes to enable = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date -error[E0658]: use of unstable library feature `view_type_macro` +error[E0658]: use of unstable library feature `view_types` --> $DIR/feature-gate-view-types.rs:12:15 | LL | type FooBaz = view_type!(Foo.{ baz }); | ^^^^^^^^^ | = note: see issue #155938 for more information - = help: add `#![feature(view_type_macro)]` to the crate attributes to enable + = help: add `#![feature(view_types)]` to the crate attributes to enable = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date error: aborting due to 2 previous errors diff --git a/tests/ui/view-types/hygiene.rs b/tests/ui/view-types/hygiene.rs index 15a9f7f228f90..20d184e184697 100644 --- a/tests/ui/view-types/hygiene.rs +++ b/tests/ui/view-types/hygiene.rs @@ -1,7 +1,7 @@ //@ run-pass //@ aux-build: hygiene.rs -#![feature(view_types, view_type_macro, decl_macro)] +#![feature(view_types, decl_macro)] #![allow(unused)] extern crate hygiene; diff --git a/tests/ui/view-types/must-be-struct.rs b/tests/ui/view-types/must-be-struct.rs index fb30ef1234cc5..2ee8fb6430f13 100644 --- a/tests/ui/view-types/must-be-struct.rs +++ b/tests/ui/view-types/must-be-struct.rs @@ -1,5 +1,4 @@ -#![feature(view_types, view_type_macro)] -#![allow(unused)] +#![feature(view_types)] use std::view::view_type; diff --git a/tests/ui/view-types/must-be-struct.stderr b/tests/ui/view-types/must-be-struct.stderr index 3d47e4903af6c..51b6f0bec8ebe 100644 --- a/tests/ui/view-types/must-be-struct.stderr +++ b/tests/ui/view-types/must-be-struct.stderr @@ -1,17 +1,17 @@ error: only structs can be viewed - --> $DIR/must-be-struct.rs:11:9 + --> $DIR/must-be-struct.rs:10:9 | LL | fn f(_: view_type!(Foo.{})) {} | ^^^^^^^^^^^^^^^^^^ `Foo` is an enum, it cannot be viewed error: only structs can be viewed - --> $DIR/must-be-struct.rs:13:9 + --> $DIR/must-be-struct.rs:12:9 | LL | fn g(_: view_type!(u8.{})) {} | ^^^^^^^^^^^^^^^^^ type `u8` cannot be viewed error: only structs can be viewed - --> $DIR/must-be-struct.rs:15:9 + --> $DIR/must-be-struct.rs:14:9 | LL | fn h(_: view_type!(char.{})) {} | ^^^^^^^^^^^^^^^^^^^ type `char` cannot be viewed diff --git a/tests/ui/view-types/must-exist.rs b/tests/ui/view-types/must-exist.rs index efb43eb509e9c..da912c1ee9749 100644 --- a/tests/ui/view-types/must-exist.rs +++ b/tests/ui/view-types/must-exist.rs @@ -1,5 +1,4 @@ -#![feature(view_types, view_type_macro)] -#![allow(unused)] +#![feature(view_types)] use std::view::view_type; diff --git a/tests/ui/view-types/must-exist.stderr b/tests/ui/view-types/must-exist.stderr index a775ad84a7edf..d977f060754d2 100644 --- a/tests/ui/view-types/must-exist.stderr +++ b/tests/ui/view-types/must-exist.stderr @@ -1,11 +1,11 @@ error[E0609]: no field `bar` on type `S` - --> $DIR/must-exist.rs:10:24 + --> $DIR/must-exist.rs:9:24 | LL | fn f(_: view_type!(S.{ bar })) {} | ^^^ error[E0609]: no field `bar` on type `S` - --> $DIR/must-exist.rs:12:29 + --> $DIR/must-exist.rs:11:29 | LL | fn g(_: view_type!(S.{ foo, bar })) {} | ^^^ diff --git a/tests/ui/view-types/must-restrict.rs b/tests/ui/view-types/must-restrict.rs index c0e1f5115d27c..a523f07e9aadd 100644 --- a/tests/ui/view-types/must-restrict.rs +++ b/tests/ui/view-types/must-restrict.rs @@ -1,7 +1,7 @@ //@ known-bug: unknown //@ run-pass -#![feature(view_types, view_type_macro)] +#![feature(view_types)] #![allow(unused)] use std::view::view_type; diff --git a/tests/ui/view-types/syntax-errors.rs b/tests/ui/view-types/syntax-errors.rs index 18ccb859d549e..84bcb977827e0 100644 --- a/tests/ui/view-types/syntax-errors.rs +++ b/tests/ui/view-types/syntax-errors.rs @@ -1,5 +1,4 @@ -#![feature(view_types, view_type_macro)] -#![allow(unused)] +#![feature(view_types)] use std::view::view_type; diff --git a/tests/ui/view-types/syntax-errors.stderr b/tests/ui/view-types/syntax-errors.stderr index 1c1e5fdafae1a..479151b267e2e 100644 --- a/tests/ui/view-types/syntax-errors.stderr +++ b/tests/ui/view-types/syntax-errors.stderr @@ -1,17 +1,17 @@ error: expected identifier, found reserved identifier `_` - --> $DIR/syntax-errors.rs:12:49 + --> $DIR/syntax-errors.rs:11:49 | LL | fn not_a_field(self: &mut view_type!(Self.{ _ }), _: &mut view_type!(Foo.{ _ })) {} | ^ expected identifier, found reserved identifier error: expected identifier, found reserved identifier `_` - --> $DIR/syntax-errors.rs:12:80 + --> $DIR/syntax-errors.rs:11:80 | LL | fn not_a_field(self: &mut view_type!(Self.{ _ }), _: &mut view_type!(Foo.{ _ })) {} | ^ expected identifier, found reserved identifier error: expected identifier, found keyword `where` - --> $DIR/syntax-errors.rs:18:44 + --> $DIR/syntax-errors.rs:17:44 | LL | fn keyword(self: &mut view_type!(Foo.{ where }), _: &mut view_type!(Foo.{ for })) {} | ^^^^^ expected identifier, found keyword @@ -22,7 +22,7 @@ LL | fn keyword(self: &mut view_type!(Foo.{ r#where }), _: &mut view_type!(F | ++ error: expected identifier, found keyword `for` - --> $DIR/syntax-errors.rs:18:79 + --> $DIR/syntax-errors.rs:17:79 | LL | fn keyword(self: &mut view_type!(Foo.{ where }), _: &mut view_type!(Foo.{ for })) {} | ^^^ expected identifier, found keyword @@ -33,7 +33,7 @@ LL | fn keyword(self: &mut view_type!(Foo.{ where }), _: &mut view_type!(Foo | ++ error: expected one of `,` or `}`, found `baz` - --> $DIR/syntax-errors.rs:24:49 + --> $DIR/syntax-errors.rs:23:49 | LL | fn no_comma(self: &mut view_type!(Foo.{ bar baz }), _: &mut view_type!(Foo.{ bar baz })) {} | -^^^ expected one of `,` or `}` @@ -41,7 +41,7 @@ LL | fn no_comma(self: &mut view_type!(Foo.{ bar baz }), _: &mut view_type!( | help: missing `,` error: expected one of `,` or `}`, found `baz` - --> $DIR/syntax-errors.rs:24:86 + --> $DIR/syntax-errors.rs:23:86 | LL | fn no_comma(self: &mut view_type!(Foo.{ bar baz }), _: &mut view_type!(Foo.{ bar baz })) {} | -^^^ expected one of `,` or `}` @@ -49,25 +49,25 @@ LL | fn no_comma(self: &mut view_type!(Foo.{ bar baz }), _: &mut view_type!( | help: missing `,` error[E0609]: no field `_` on type `Foo` - --> $DIR/syntax-errors.rs:12:49 + --> $DIR/syntax-errors.rs:11:49 | LL | fn not_a_field(self: &mut view_type!(Self.{ _ }), _: &mut view_type!(Foo.{ _ })) {} | ^ error[E0609]: no field `_` on type `Foo` - --> $DIR/syntax-errors.rs:12:80 + --> $DIR/syntax-errors.rs:11:80 | LL | fn not_a_field(self: &mut view_type!(Self.{ _ }), _: &mut view_type!(Foo.{ _ })) {} | ^ error[E0609]: no field `r#where` on type `Foo` - --> $DIR/syntax-errors.rs:18:44 + --> $DIR/syntax-errors.rs:17:44 | LL | fn keyword(self: &mut view_type!(Foo.{ where }), _: &mut view_type!(Foo.{ for })) {} | ^^^^^ error[E0609]: no field `r#for` on type `Foo` - --> $DIR/syntax-errors.rs:18:79 + --> $DIR/syntax-errors.rs:17:79 | LL | fn keyword(self: &mut view_type!(Foo.{ where }), _: &mut view_type!(Foo.{ for })) {} | ^^^ diff --git a/tests/ui/view-types/tuple-structs.rs b/tests/ui/view-types/tuple-structs.rs index f0442d4e308fb..04dd222cef98d 100644 --- a/tests/ui/view-types/tuple-structs.rs +++ b/tests/ui/view-types/tuple-structs.rs @@ -1,6 +1,6 @@ //@ run-pass -#![feature(view_types, view_type_macro)] +#![feature(view_types)] #![allow(unused)] use std::view::view_type;