diff --git a/Cargo.lock b/Cargo.lock
index be704e84a508c..60daa453c60dd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3757,7 +3757,6 @@ dependencies = [
"rustc_middle",
"rustc_session",
"rustc_span",
- "rustc_target",
"rustc_trait_selection",
"smallvec",
"tracing",
@@ -3796,6 +3795,7 @@ dependencies = [
"rustc_middle",
"rustc_session",
"rustc_span",
+ "rustc_target",
"rustc_trait_selection",
"smallvec",
"tracing",
diff --git a/compiler/rustc_codegen_cranelift/src/lib.rs b/compiler/rustc_codegen_cranelift/src/lib.rs
index 9d9e790289cf6..ab09a6f8b38e1 100644
--- a/compiler/rustc_codegen_cranelift/src/lib.rs
+++ b/compiler/rustc_codegen_cranelift/src/lib.rs
@@ -41,8 +41,8 @@ use std::sync::Arc;
use cranelift_codegen::isa::TargetIsa;
use cranelift_codegen::settings::{self, Configurable};
-use rustc_codegen_ssa::CodegenResults;
use rustc_codegen_ssa::traits::CodegenBackend;
+use rustc_codegen_ssa::{CodegenResults, TargetConfig};
use rustc_metadata::EncodedMetadata;
use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
use rustc_session::Session;
@@ -178,7 +178,7 @@ impl CodegenBackend for CraneliftCodegenBackend {
}
}
- fn target_features_cfg(&self, sess: &Session) -> (Vec<Symbol>, Vec<Symbol>) {
+ fn target_config(&self, sess: &Session) -> TargetConfig {
// FIXME return the actually used target features. this is necessary for #[cfg(target_feature)]
let target_features = if sess.target.arch == "x86_64" && sess.target.os != "none" {
// x86_64 mandates SSE2 support and rustc requires the x87 feature to be enabled
@@ -197,7 +197,16 @@ impl CodegenBackend for CraneliftCodegenBackend {
};
// FIXME do `unstable_target_features` properly
let unstable_target_features = target_features.clone();
- (target_features, unstable_target_features)
+
+ TargetConfig {
+ target_features,
+ unstable_target_features,
+ // Cranelift does not yet support f16 or f128
+ has_reliable_f16: false,
+ has_reliable_f16_math: false,
+ has_reliable_f128: false,
+ has_reliable_f128_math: false,
+ }
}
fn print_version(&self) {
diff --git a/compiler/rustc_codegen_gcc/src/gcc_util.rs b/compiler/rustc_codegen_gcc/src/gcc_util.rs
index 955f902023573..2b053abdd190a 100644
--- a/compiler/rustc_codegen_gcc/src/gcc_util.rs
+++ b/compiler/rustc_codegen_gcc/src/gcc_util.rs
@@ -55,7 +55,7 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
)
} else if let Some(feature) = feature.strip_prefix('-') {
// FIXME: Why do we not remove implied features on "-" here?
- // We do the equivalent above in `target_features_cfg`.
+ // We do the equivalent above in `target_config`.
// See <https://github.com/rust-lang/rust/issues/134792>.
all_rust_features.push((false, feature));
} else if !feature.is_empty() && diagnostics {
diff --git a/compiler/rustc_codegen_gcc/src/lib.rs b/compiler/rustc_codegen_gcc/src/lib.rs
index 555f164e53fd6..2c5a787168381 100644
--- a/compiler/rustc_codegen_gcc/src/lib.rs
+++ b/compiler/rustc_codegen_gcc/src/lib.rs
@@ -102,7 +102,7 @@ use rustc_codegen_ssa::back::write::{
};
use rustc_codegen_ssa::base::codegen_crate;
use rustc_codegen_ssa::traits::{CodegenBackend, ExtraBackendMethods, WriteBackendMethods};
-use rustc_codegen_ssa::{CodegenResults, CompiledModule, ModuleCodegen};
+use rustc_codegen_ssa::{CodegenResults, CompiledModule, ModuleCodegen, TargetConfig};
use rustc_data_structures::fx::FxIndexMap;
use rustc_data_structures::sync::IntoDynSyncSend;
use rustc_errors::DiagCtxtHandle;
@@ -260,8 +260,8 @@ impl CodegenBackend for GccCodegenBackend {
.join(sess)
}
- fn target_features_cfg(&self, sess: &Session) -> (Vec<Symbol>, Vec<Symbol>) {
- target_features_cfg(sess, &self.target_info)
+ fn target_config(&self, sess: &Session) -> TargetConfig {
+ target_config(sess, &self.target_info)
}
}
@@ -485,10 +485,7 @@ fn to_gcc_opt_level(optlevel: Option<OptLevel>) -> OptimizationLevel {
}
/// Returns the features that should be set in `cfg(target_feature)`.
-fn target_features_cfg(
- sess: &Session,
- target_info: &LockedTargetInfo,
-) -> (Vec<Symbol>, Vec<Symbol>) {
+fn target_config(sess: &Session, target_info: &LockedTargetInfo) -> TargetConfig {
// TODO(antoyo): use global_gcc_features.
let f = |allow_unstable| {
sess.target
@@ -523,5 +520,14 @@ fn target_features_cfg(
let target_features = f(false);
let unstable_target_features = f(true);
- (target_features, unstable_target_features)
+
+ TargetConfig {
+ target_features,
+ unstable_target_features,
+ // There are no known bugs with GCC support for f16 or f128
+ has_reliable_f16: true,
+ has_reliable_f16_math: true,
+ has_reliable_f128: true,
+ has_reliable_f128_math: true,
+ }
}
diff --git a/compiler/rustc_codegen_llvm/src/attributes.rs b/compiler/rustc_codegen_llvm/src/attributes.rs
index e8c42d16733ec..176fb72dfdc5e 100644
--- a/compiler/rustc_codegen_llvm/src/attributes.rs
+++ b/compiler/rustc_codegen_llvm/src/attributes.rs
@@ -1,5 +1,4 @@
//! Set and unset common attributes on LLVM values.
-
use rustc_attr_parsing::{InlineAttr, InstructionSetAttr, OptimizeAttr};
use rustc_codegen_ssa::traits::*;
use rustc_hir::def_id::DefId;
@@ -28,6 +27,22 @@ pub(crate) fn apply_to_callsite(callsite: &Value, idx: AttributePlace, attrs: &[
}
}
+pub(crate) fn has_attr(llfn: &Value, idx: AttributePlace, attr: AttributeKind) -> bool {
+ llvm::HasAttributeAtIndex(llfn, idx, attr)
+}
+
+pub(crate) fn has_string_attr(llfn: &Value, name: &str) -> bool {
+ llvm::HasStringAttribute(llfn, name)
+}
+
+pub(crate) fn remove_from_llfn(llfn: &Value, place: AttributePlace, kind: AttributeKind) {
+ llvm::RemoveRustEnumAttributeAtIndex(llfn, place, kind);
+}
+
+pub(crate) fn remove_string_attr_from_llfn(llfn: &Value, name: &str) {
+ llvm::RemoveStringAttrFromFn(llfn, name);
+}
+
/// Get LLVM attribute for the provided inline heuristic.
#[inline]
fn inline_attr<'ll>(cx: &CodegenCx<'ll, '_>, inline: InlineAttr) -> Option<&'ll Attribute> {
diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/compiler/rustc_codegen_llvm/src/back/lto.rs
index 925898d817371..39b3a23e0b1b0 100644
--- a/compiler/rustc_codegen_llvm/src/back/lto.rs
+++ b/compiler/rustc_codegen_llvm/src/back/lto.rs
@@ -28,8 +28,9 @@ use crate::back::write::{
use crate::errors::{
DynamicLinkingWithLTO, LlvmError, LtoBitcodeFromRlib, LtoDisallowed, LtoDylib, LtoProcMacro,
};
+use crate::llvm::AttributePlace::Function;
use crate::llvm::{self, build_string};
-use crate::{LlvmCodegenBackend, ModuleLlvm};
+use crate::{LlvmCodegenBackend, ModuleLlvm, SimpleCx, attributes};
/// We keep track of the computed LTO cache keys from the previous
/// session to determine which CGUs we can reuse.
@@ -666,6 +667,31 @@ pub(crate) fn run_pass_manager(
}
if cfg!(llvm_enzyme) && enable_ad && !thin {
+ let cx =
+ SimpleCx::new(module.module_llvm.llmod(), &module.module_llvm.llcx, cgcx.pointer_size);
+
+ for function in cx.get_functions() {
+ let enzyme_marker = "enzyme_marker";
+ if attributes::has_string_attr(function, enzyme_marker) {
+ // Sanity check: Ensure 'noinline' is present before replacing it.
+ assert!(
+ !attributes::has_attr(function, Function, llvm::AttributeKind::NoInline),
+ "Expected __enzyme function to have 'noinline' before adding 'alwaysinline'"
+ );
+
+ attributes::remove_from_llfn(function, Function, llvm::AttributeKind::NoInline);
+ attributes::remove_string_attr_from_llfn(function, enzyme_marker);
+
+ assert!(
+ !attributes::has_string_attr(function, enzyme_marker),
+ "Expected function to not have 'enzyme_marker'"
+ );
+
+ let always_inline = llvm::AttributeKind::AlwaysInline.create_attr(cx.llcx);
+ attributes::apply_to_llfn(function, Function, &[always_inline]);
+ }
+ }
+
let opt_stage = llvm::OptStage::FatLTO;
let stage = write::AutodiffStage::PostAD;
if !config.autodiff.contains(&config::AutoDiff::NoPostopt) {
diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
index 0147bd5a66581..c5c13ac097a27 100644
--- a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
+++ b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
@@ -361,6 +361,11 @@ fn generate_enzyme_call<'ll>(
let attr = llvm::AttributeKind::NoInline.create_attr(cx.llcx);
attributes::apply_to_llfn(ad_fn, Function, &[attr]);
+ // We add a made-up attribute just such that we can recognize it after AD to update
+ // (no)-inline attributes. We'll then also remove this attribute.
+ let enzyme_marker_attr = llvm::CreateAttrString(cx.llcx, "enzyme_marker");
+ attributes::apply_to_llfn(outer_fn, Function, &[enzyme_marker_attr]);
+
// first, remove all calls from fnc
let entry = llvm::LLVMGetFirstBasicBlock(outer_fn);
let br = llvm::LLVMRustGetTerminator(entry);
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 4ec6999551898..ed50515b70716 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -698,6 +698,16 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
llvm::LLVMMDStringInContext2(self.llcx(), name.as_ptr() as *const c_char, name.len())
})
}
+
+ pub(crate) fn get_functions(&self) -> Vec<&'ll Value> {
+ let mut functions = vec![];
+ let mut func = unsafe { llvm::LLVMGetFirstFunction(self.llmod()) };
+ while let Some(f) = func {
+ functions.push(f);
+ func = unsafe { llvm::LLVMGetNextFunction(f) }
+ }
+ functions
+ }
}
impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index b2feeacdb4664..e8010ec9fc495 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -29,7 +29,7 @@ use back::owned_target_machine::OwnedTargetMachine;
use back::write::{create_informational_target_machine, create_target_machine};
use context::SimpleCx;
use errors::{AutoDiffWithoutLTO, ParseTargetMachineConfig};
-use llvm_util::target_features_cfg;
+use llvm_util::target_config;
use rustc_ast::expand::allocator::AllocatorKind;
use rustc_ast::expand::autodiff_attrs::AutoDiffItem;
use rustc_codegen_ssa::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule};
@@ -37,7 +37,7 @@ use rustc_codegen_ssa::back::write::{
CodegenContext, FatLtoInput, ModuleConfig, TargetMachineFactoryConfig, TargetMachineFactoryFn,
};
use rustc_codegen_ssa::traits::*;
-use rustc_codegen_ssa::{CodegenResults, CompiledModule, ModuleCodegen};
+use rustc_codegen_ssa::{CodegenResults, CompiledModule, ModuleCodegen, TargetConfig};
use rustc_data_structures::fx::FxIndexMap;
use rustc_errors::{DiagCtxtHandle, FatalError};
use rustc_metadata::EncodedMetadata;
@@ -338,8 +338,8 @@ impl CodegenBackend for LlvmCodegenBackend {
llvm_util::print_version();
}
- fn target_features_cfg(&self, sess: &Session) -> (Vec<Symbol>, Vec<Symbol>) {
- target_features_cfg(sess)
+ fn target_config(&self, sess: &Session) -> TargetConfig {
+ target_config(sess)
}
fn codegen_crate<'tcx>(
diff --git a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
index a9b3bdf7344be..2ad39fc853819 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
@@ -19,6 +19,19 @@ unsafe extern "C" {
pub(crate) fn LLVMRustVerifyFunction(V: &Value, action: LLVMRustVerifierFailureAction) -> Bool;
pub(crate) fn LLVMRustHasAttributeAtIndex(V: &Value, i: c_uint, Kind: AttributeKind) -> bool;
pub(crate) fn LLVMRustGetArrayNumElements(Ty: &Type) -> u64;
+ pub(crate) fn LLVMRustHasFnAttribute(
+ F: &Value,
+ Name: *const c_char,
+ NameLen: libc::size_t,
+ ) -> bool;
+ pub(crate) fn LLVMRustRemoveFnAttribute(F: &Value, Name: *const c_char, NameLen: libc::size_t);
+ pub(crate) fn LLVMGetFirstFunction(M: &Module) -> Option<&Value>;
+ pub(crate) fn LLVMGetNextFunction(Fn: &Value) -> Option<&Value>;
+ pub(crate) fn LLVMRustRemoveEnumAttributeAtIndex(
+ Fn: &Value,
+ index: c_uint,
+ kind: AttributeKind,
+ );
}
unsafe extern "C" {
diff --git a/compiler/rustc_codegen_llvm/src/llvm/mod.rs b/compiler/rustc_codegen_llvm/src/llvm/mod.rs
index 6ca81c651ed42..d14aab060731a 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/mod.rs
@@ -41,6 +41,32 @@ pub(crate) fn AddFunctionAttributes<'ll>(
}
}
+pub(crate) fn HasAttributeAtIndex<'ll>(
+ llfn: &'ll Value,
+ idx: AttributePlace,
+ kind: AttributeKind,
+) -> bool {
+ unsafe { LLVMRustHasAttributeAtIndex(llfn, idx.as_uint(), kind) }
+}
+
+pub(crate) fn HasStringAttribute<'ll>(llfn: &'ll Value, name: &str) -> bool {
+ unsafe { LLVMRustHasFnAttribute(llfn, name.as_c_char_ptr(), name.len()) }
+}
+
+pub(crate) fn RemoveStringAttrFromFn<'ll>(llfn: &'ll Value, name: &str) {
+ unsafe { LLVMRustRemoveFnAttribute(llfn, name.as_c_char_ptr(), name.len()) }
+}
+
+pub(crate) fn RemoveRustEnumAttributeAtIndex(
+ llfn: &Value,
+ place: AttributePlace,
+ kind: AttributeKind,
+) {
+ unsafe {
+ LLVMRustRemoveEnumAttributeAtIndex(llfn, place.as_uint(), kind);
+ }
+}
+
pub(crate) fn AddCallSiteAttributes<'ll>(
callsite: &'ll Value,
idx: AttributePlace,
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 36e35f81392bc..ae1bdac1655d3 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -6,6 +6,7 @@ use std::sync::Once;
use std::{ptr, slice, str};
use libc::c_int;
+use rustc_codegen_ssa::TargetConfig;
use rustc_codegen_ssa::base::wants_wasm_eh;
use rustc_codegen_ssa::codegen_attrs::check_tied_features;
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
@@ -302,7 +303,7 @@ pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> Option<LLVMFea
/// Must express features in the way Rust understands them.
///
/// We do not have to worry about RUSTC_SPECIFIC_FEATURES here, those are handled outside codegen.
-pub(crate) fn target_features_cfg(sess: &Session) -> (Vec<Symbol>, Vec<Symbol>) {
+pub(crate) fn target_config(sess: &Session) -> TargetConfig {
// Add base features for the target.
// We do *not* add the -Ctarget-features there, and instead duplicate the logic for that below.
// The reason is that if LLVM considers a feature implied but we do not, we don't want that to
@@ -402,7 +403,89 @@ pub(crate) fn target_features_cfg(sess: &Session) -> (Vec<Symbol>, Vec<Symbol>)
let target_features = f(false);
let unstable_target_features = f(true);
- (target_features, unstable_target_features)
+ let mut cfg = TargetConfig {
+ target_features,
+ unstable_target_features,
+ has_reliable_f16: true,
+ has_reliable_f16_math: true,
+ has_reliable_f128: true,
+ has_reliable_f128_math: true,
+ };
+
+ update_target_reliable_float_cfg(sess, &mut cfg);
+ cfg
+}
+
+/// Determine whether or not experimental float types are reliable based on known bugs.
+fn update_target_reliable_float_cfg(sess: &Session, cfg: &mut TargetConfig) {
+ let target_arch = sess.target.arch.as_ref();
+ let target_os = sess.target.options.os.as_ref();
+ let target_env = sess.target.options.env.as_ref();
+ let target_abi = sess.target.options.abi.as_ref();
+ let target_pointer_width = sess.target.pointer_width;
+
+ cfg.has_reliable_f16 = match (target_arch, target_os) {
+ // Selection failure <https://github.com/llvm/llvm-project/issues/50374>
+ ("s390x", _) => false,
+ // Unsupported <https://github.com/llvm/llvm-project/issues/94434>
+ ("arm64ec", _) => false,
+ // MinGW ABI bugs <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115054>
+ ("x86_64", "windows") if target_env == "gnu" && target_abi != "llvm" => false,
+ // Infinite recursion <https://github.com/llvm/llvm-project/issues/97981>
+ ("csky", _) => false,
+ ("hexagon", _) => false,
+ ("powerpc" | "powerpc64", _) => false,
+ ("sparc" | "sparc64", _) => false,
+ ("wasm32" | "wasm64", _) => false,
+ // `f16` support only requires that symbols converting to and from `f32` are available. We
+ // provide these in `compiler-builtins`, so `f16` should be available on all platforms that
+ // do not have other ABI issues or LLVM crashes.
+ _ => true,
+ };
+
+ cfg.has_reliable_f128 = match (target_arch, target_os) {
+ // Unsupported <https://github.com/llvm/llvm-project/issues/94434>
+ ("arm64ec", _) => false,
+ // Selection bug <https://github.com/llvm/llvm-project/issues/96432>
+ ("mips64" | "mips64r6", _) => false,
+ // Selection bug <https://github.com/llvm/llvm-project/issues/95471>
+ ("nvptx64", _) => false,
+ // ABI bugs <https://github.com/rust-lang/rust/issues/125109> et al. (full
+ // list at <https://github.com/rust-lang/rust/issues/116909>)
+ ("powerpc" | "powerpc64", _) => false,
+ // ABI unsupported <https://github.com/llvm/llvm-project/issues/41838>
+ ("sparc", _) => false,
+ // Stack alignment bug <https://github.com/llvm/llvm-project/issues/77401>. NB: tests may
+ // not fail if our compiler-builtins is linked.
+ ("x86", _) => false,
+ // MinGW ABI bugs <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115054>
+ ("x86_64", "windows") if target_env == "gnu" && target_abi != "llvm" => false,
+ // There are no known problems on other platforms, so the only requirement is that symbols
+ // are available. `compiler-builtins` provides all symbols required for core `f128`
+ // support, so this should work for everything else.
+ _ => true,
+ };
+
+ cfg.has_reliable_f16_math = match (target_arch, target_os) {
+ // x86 has a crash for `powi`: <https://github.com/llvm/llvm-project/issues/105747>
+ ("x86" | "x86_64", _) => false,
+ // Assume that working `f16` means working `f16` math for most platforms, since
+ // operations just go through `f32`.
+ _ => true,
+ } && cfg.has_reliable_f16;
+
+ cfg.has_reliable_f128_math = match (target_arch, target_os) {
+ // LLVM lowers `fp128` math to `long double` symbols even on platforms where
+ // `long double` is not IEEE binary128. See
+ // <https://github.com/llvm/llvm-project/issues/44744>.
+ //
+ // This rules out anything that doesn't have `long double` = `binary128`; <= 32 bits
+ // (ld is `f64`), anything other than Linux (Windows and MacOS use `f64`), and `x86`
+ // (ld is 80-bit extended precision).
+ ("x86_64", _) => false,
+ (_, "linux") if target_pointer_width == 64 => true,
+ _ => false,
+ } && cfg.has_reliable_f128;
}
pub(crate) fn print_version() {
@@ -686,7 +769,7 @@ pub(crate) fn global_llvm_features(
)
} else if let Some(feature) = feature.strip_prefix('-') {
// FIXME: Why do we not remove implied features on "-" here?
- // We do the equivalent above in `target_features_cfg`.
+ // We do the equivalent above in `target_config`.
// See <https://github.com/rust-lang/rust/issues/134792>.
all_rust_features.push((false, feature));
} else if !feature.is_empty() {
diff --git a/compiler/rustc_codegen_llvm/src/type_.rs b/compiler/rustc_codegen_llvm/src/type_.rs
index b89ce90d1a1dc..169036f515298 100644
--- a/compiler/rustc_codegen_llvm/src/type_.rs
+++ b/compiler/rustc_codegen_llvm/src/type_.rs
@@ -128,6 +128,10 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
(**self).borrow().llcx
}
+ pub(crate) fn llmod(&self) -> &'ll llvm::Module {
+ (**self).borrow().llmod
+ }
+
pub(crate) fn isize_ty(&self) -> &'ll Type {
(**self).borrow().isize_ty
}
diff --git a/compiler/rustc_codegen_ssa/src/lib.rs b/compiler/rustc_codegen_ssa/src/lib.rs
index c927aae2c4c2b..b67c871cac9fe 100644
--- a/compiler/rustc_codegen_ssa/src/lib.rs
+++ b/compiler/rustc_codegen_ssa/src/lib.rs
@@ -235,6 +235,24 @@ pub struct CrateInfo {
pub lint_levels: CodegenLintLevels,
}
+/// Target-specific options that get set in `cfg(...)`.
+///
+/// RUSTC_SPECIFIC_FEATURES should be skipped here, those are handled outside codegen.
+pub struct TargetConfig {
+ /// Options to be set in `cfg(target_features)`.
+ pub target_features: Vec<Symbol>,
+ /// Options to be set in `cfg(target_features)`, but including unstable features.
+ pub unstable_target_features: Vec<Symbol>,
+ /// Option for `cfg(target_has_reliable_f16)`, true if `f16` basic arithmetic works.
+ pub has_reliable_f16: bool,
+ /// Option for `cfg(target_has_reliable_f16_math)`, true if `f16` math calls work.
+ pub has_reliable_f16_math: bool,
+ /// Option for `cfg(target_has_reliable_f128)`, true if `f128` basic arithmetic works.
+ pub has_reliable_f128: bool,
+ /// Option for `cfg(target_has_reliable_f128_math)`, true if `f128` math calls work.
+ pub has_reliable_f128_math: bool,
+}
+
#[derive(Encodable, Decodable)]
pub struct CodegenResults {
pub modules: Vec<CompiledModule>,
diff --git a/compiler/rustc_codegen_ssa/src/traits/backend.rs b/compiler/rustc_codegen_ssa/src/traits/backend.rs
index 65fd843e7a59e..e6b50cc7c0cbf 100644
--- a/compiler/rustc_codegen_ssa/src/traits/backend.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/backend.rs
@@ -18,7 +18,7 @@ use super::write::WriteBackendMethods;
use crate::back::archive::ArArchiveBuilderBuilder;
use crate::back::link::link_binary;
use crate::back::write::TargetMachineFactoryFn;
-use crate::{CodegenResults, ModuleCodegen};
+use crate::{CodegenResults, ModuleCodegen, TargetConfig};
pub trait BackendTypes {
type Value: CodegenObject;
@@ -50,8 +50,15 @@ pub trait CodegenBackend {
/// - The second is like the first, but also includes unstable features.
///
/// RUSTC_SPECIFIC_FEATURES should be skipped here, those are handled outside codegen.
- fn target_features_cfg(&self, _sess: &Session) -> (Vec<Symbol>, Vec<Symbol>) {
- (vec![], vec![])
+ fn target_config(&self, _sess: &Session) -> TargetConfig {
+ TargetConfig {
+ target_features: vec![],
+ unstable_target_features: vec![],
+ has_reliable_f16: true,
+ has_reliable_f16_math: true,
+ has_reliable_f128: true,
+ has_reliable_f128_math: true,
+ }
}
fn print_passes(&self) {}
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index 43ba67e7dc63b..a5e6b1c00d693 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -40,6 +40,26 @@ const GATED_CFGS: &[GatedCfg] = &[
// this is consistent with naming of the compiler flag it's for
(sym::fmt_debug, sym::fmt_debug, Features::fmt_debug),
(sym::emscripten_wasm_eh, sym::cfg_emscripten_wasm_eh, Features::cfg_emscripten_wasm_eh),
+ (
+ sym::target_has_reliable_f16,
+ sym::cfg_target_has_reliable_f16_f128,
+ Features::cfg_target_has_reliable_f16_f128,
+ ),
+ (
+ sym::target_has_reliable_f16_math,
+ sym::cfg_target_has_reliable_f16_f128,
+ Features::cfg_target_has_reliable_f16_f128,
+ ),
+ (
+ sym::target_has_reliable_f128,
+ sym::cfg_target_has_reliable_f16_f128,
+ Features::cfg_target_has_reliable_f16_f128,
+ ),
+ (
+ sym::target_has_reliable_f128_math,
+ sym::cfg_target_has_reliable_f16_f128,
+ Features::cfg_target_has_reliable_f16_f128,
+ ),
];
/// Find a gated cfg determined by the `pred`icate which is given the cfg's name.
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 8a31a03db7297..75e09cacb1f1e 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -205,6 +205,8 @@ declare_features! (
(unstable, anonymous_lifetime_in_impl_trait, "1.63.0", None),
/// Allows access to the emscripten_wasm_eh config, used by panic_unwind and unwind
(internal, cfg_emscripten_wasm_eh, "1.86.0", None),
+ /// Allows checking whether or not the backend correctly supports unstable float types.
+ (internal, cfg_target_has_reliable_f16_f128, "CURRENT_RUSTC_VERSION", None),
/// Allows identifying the `compiler_builtins` crate.
(internal, compiler_builtins, "1.13.0", None),
/// Allows writing custom MIR
diff --git a/compiler/rustc_hir_analysis/Cargo.toml b/compiler/rustc_hir_analysis/Cargo.toml
index e5017794d8f29..58213c4f4e462 100644
--- a/compiler/rustc_hir_analysis/Cargo.toml
+++ b/compiler/rustc_hir_analysis/Cargo.toml
@@ -26,7 +26,6 @@ rustc_macros = { path = "../rustc_macros" }
rustc_middle = { path = "../rustc_middle" }
rustc_session = { path = "../rustc_session" }
rustc_span = { path = "../rustc_span" }
-rustc_target = { path = "../rustc_target" }
rustc_trait_selection = { path = "../rustc_trait_selection" }
smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
tracing = "0.1"
diff --git a/compiler/rustc_hir_analysis/messages.ftl b/compiler/rustc_hir_analysis/messages.ftl
index 92701e3328e92..277bb7bd3e15c 100644
--- a/compiler/rustc_hir_analysis/messages.ftl
+++ b/compiler/rustc_hir_analysis/messages.ftl
@@ -450,9 +450,6 @@ hir_analysis_recursive_generic_parameter = {$param_def_kind} `{$param_name}` is
hir_analysis_redundant_lifetime_args = unnecessary lifetime parameter `{$victim}`
.note = you can use the `{$candidate}` lifetime directly, in place of `{$victim}`
-hir_analysis_register_type_unstable =
- type `{$ty}` cannot be used with this register class in stable
-
hir_analysis_requires_note = the `{$trait_name}` impl for `{$ty}` requires that `{$error_predicate}`
hir_analysis_return_type_notation_equality_bound =
diff --git a/compiler/rustc_hir_analysis/src/check/mod.rs b/compiler/rustc_hir_analysis/src/check/mod.rs
index 5fbd771976bbb..fad8abf5fae85 100644
--- a/compiler/rustc_hir_analysis/src/check/mod.rs
+++ b/compiler/rustc_hir_analysis/src/check/mod.rs
@@ -67,7 +67,6 @@ mod check;
mod compare_impl_item;
mod entry;
pub mod intrinsic;
-pub mod intrinsicck;
mod region;
pub mod wfcheck;
diff --git a/compiler/rustc_hir_analysis/src/errors.rs b/compiler/rustc_hir_analysis/src/errors.rs
index 508970cf2554d..2b1661aaac8f0 100644
--- a/compiler/rustc_hir_analysis/src/errors.rs
+++ b/compiler/rustc_hir_analysis/src/errors.rs
@@ -1675,14 +1675,6 @@ pub(crate) struct CmseEntryGeneric {
pub span: Span,
}
-#[derive(Diagnostic)]
-#[diag(hir_analysis_register_type_unstable)]
-pub(crate) struct RegisterTypeUnstable<'a> {
- #[primary_span]
- pub span: Span,
- pub ty: Ty<'a>,
-}
-
#[derive(LintDiagnostic)]
#[diag(hir_analysis_supertrait_item_shadowing)]
pub(crate) struct SupertraitItemShadowing {
diff --git a/compiler/rustc_hir_typeck/Cargo.toml b/compiler/rustc_hir_typeck/Cargo.toml
index b2b90cb29e36f..f00125c3e090a 100644
--- a/compiler/rustc_hir_typeck/Cargo.toml
+++ b/compiler/rustc_hir_typeck/Cargo.toml
@@ -22,6 +22,7 @@ rustc_macros = { path = "../rustc_macros" }
rustc_middle = { path = "../rustc_middle" }
rustc_session = { path = "../rustc_session" }
rustc_span = { path = "../rustc_span" }
+rustc_target = { path = "../rustc_target" }
rustc_trait_selection = { path = "../rustc_trait_selection" }
smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
tracing = "0.1"
diff --git a/compiler/rustc_hir_typeck/messages.ftl b/compiler/rustc_hir_typeck/messages.ftl
index 9e1b70f5767b4..23309102c4da5 100644
--- a/compiler/rustc_hir_typeck/messages.ftl
+++ b/compiler/rustc_hir_typeck/messages.ftl
@@ -179,6 +179,9 @@ hir_typeck_ptr_cast_add_auto_to_object = cannot add {$traits_len ->
.help = use `transmute` if you're sure this is sound
.label = unsupported cast
+hir_typeck_register_type_unstable =
+ type `{$ty}` cannot be used with this register class in stable
+
hir_typeck_remove_semi_for_coerce = you might have meant to return the `match` expression
hir_typeck_remove_semi_for_coerce_expr = this could be implicitly returned but it is a statement, not a tail expression
hir_typeck_remove_semi_for_coerce_ret = the `match` arms can conform to this return type
diff --git a/compiler/rustc_hir_typeck/src/errors.rs b/compiler/rustc_hir_typeck/src/errors.rs
index 9e7305430e5f5..732795535087e 100644
--- a/compiler/rustc_hir_typeck/src/errors.rs
+++ b/compiler/rustc_hir_typeck/src/errors.rs
@@ -963,3 +963,11 @@ pub(crate) enum SupertraitItemShadowee {
traits: DiagSymbolList,
},
}
+
+#[derive(Diagnostic)]
+#[diag(hir_typeck_register_type_unstable)]
+pub(crate) struct RegisterTypeUnstable<'a> {
+ #[primary_span]
+ pub span: Span,
+ pub ty: Ty<'a>,
+}
diff --git a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
index f5e0f01e4c573..17e13ec0a376b 100644
--- a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
+++ b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
@@ -1000,13 +1000,15 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
// determines whether to borrow *at the level of the deref pattern* rather than
// borrowing the bound place (since that inner place is inside the temporary that
// stores the result of calling `deref()`/`deref_mut()` so can't be captured).
+ // Deref patterns on boxes don't borrow, so we ignore them here.
// HACK: this could be a fake pattern corresponding to a deref inserted by match
// ergonomics, in which case `pat.hir_id` will be the id of the subpattern.
- let mutable = self.cx.typeck_results().pat_has_ref_mut_binding(subpattern);
- let mutability =
- if mutable { hir::Mutability::Mut } else { hir::Mutability::Not };
- let bk = ty::BorrowKind::from_mutbl(mutability);
- self.delegate.borrow_mut().borrow(place, discr_place.hir_id, bk);
+ if let hir::ByRef::Yes(mutability) =
+ self.cx.typeck_results().deref_pat_borrow_mode(place.place.ty(), subpattern)
+ {
+ let bk = ty::BorrowKind::from_mutbl(mutability);
+ self.delegate.borrow_mut().borrow(place, discr_place.hir_id, bk);
+ }
}
PatKind::Never => {
// A `!` pattern always counts as an immutable read of the discriminant,
@@ -1691,18 +1693,19 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
place_with_id = match adjust.kind {
adjustment::PatAdjust::BuiltinDeref => self.cat_deref(pat.hir_id, place_with_id)?,
adjustment::PatAdjust::OverloadedDeref => {
- // This adjustment corresponds to an overloaded deref; it borrows the scrutinee to
- // call `Deref::deref` or `DerefMut::deref_mut`. Invoke the callback before setting
- // `place_with_id` to the temporary storing the result of the deref.
+ // This adjustment corresponds to an overloaded deref; unless it's on a box, it
+ // borrows the scrutinee to call `Deref::deref` or `DerefMut::deref_mut`. Invoke
+ // the callback before setting `place_with_id` to the temporary storing the
+ // result of the deref.
// HACK(dianne): giving the callback a fake deref pattern makes sure it behaves the
- // same as it would if this were an explicit deref pattern.
+ // same as it would if this were an explicit deref pattern (including for boxes).
op(&place_with_id, &hir::Pat { kind: PatKind::Deref(pat), ..*pat })?;
let target_ty = match adjusts.peek() {
Some(&&next_adjust) => next_adjust.source,
// At the end of the deref chain, we get `pat`'s scrutinee.
None => self.pat_ty_unadjusted(pat)?,
};
- self.pat_deref_temp(pat.hir_id, pat, target_ty)?
+ self.pat_deref_place(pat.hir_id, place_with_id, pat, target_ty)?
}
};
}
@@ -1810,7 +1813,7 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
}
PatKind::Deref(subpat) => {
let ty = self.pat_ty_adjusted(subpat)?;
- let place = self.pat_deref_temp(pat.hir_id, subpat, ty)?;
+ let place = self.pat_deref_place(pat.hir_id, place_with_id, subpat, ty)?;
self.cat_pattern(place, subpat, op)?;
}
@@ -1863,21 +1866,27 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
Ok(())
}
- /// Represents the place of the temp that stores the scrutinee of a deref pattern's interior.
- fn pat_deref_temp(
+ /// Represents the place matched on by a deref pattern's interior.
+ fn pat_deref_place(
&self,
hir_id: HirId,
+ base_place: PlaceWithHirId<'tcx>,
inner: &hir::Pat<'_>,
target_ty: Ty<'tcx>,
) -> Result<PlaceWithHirId<'tcx>, Cx::Error> {
- let mutable = self.cx.typeck_results().pat_has_ref_mut_binding(inner);
- let mutability = if mutable { hir::Mutability::Mut } else { hir::Mutability::Not };
- let re_erased = self.cx.tcx().lifetimes.re_erased;
- let ty = Ty::new_ref(self.cx.tcx(), re_erased, target_ty, mutability);
- // A deref pattern stores the result of `Deref::deref` or `DerefMut::deref_mut` ...
- let base = self.cat_rvalue(hir_id, ty);
- // ... and the inner pattern matches on the place behind that reference.
- self.cat_deref(hir_id, base)
+ match self.cx.typeck_results().deref_pat_borrow_mode(base_place.place.ty(), inner) {
+ // Deref patterns on boxes are lowered using a built-in deref.
+ hir::ByRef::No => self.cat_deref(hir_id, base_place),
+ // For other types, we create a temporary to match on.
+ hir::ByRef::Yes(mutability) => {
+ let re_erased = self.cx.tcx().lifetimes.re_erased;
+ let ty = Ty::new_ref(self.cx.tcx(), re_erased, target_ty, mutability);
+ // A deref pattern stores the result of `Deref::deref` or `DerefMut::deref_mut` ...
+ let base = self.cat_rvalue(hir_id, ty);
+ // ... and the inner pattern matches on the place behind that reference.
+ self.cat_deref(hir_id, base)
+ }
+ }
}
fn is_multivariant_adt(&self, ty: Ty<'tcx>, span: Span) -> bool {
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index 8b2d9ab297905..e70aa1a70645e 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -8,7 +8,6 @@ use rustc_hir::def::{CtorOf, DefKind, Res};
use rustc_hir::def_id::DefId;
use rustc_hir::intravisit::Visitor;
use rustc_hir::{ExprKind, HirId, Node, QPath};
-use rustc_hir_analysis::check::intrinsicck::InlineAsmCtxt;
use rustc_hir_analysis::check::potentially_plural_count;
use rustc_hir_analysis::hir_ty_lowering::HirTyLowerer;
use rustc_index::IndexVec;
@@ -33,6 +32,7 @@ use crate::errors::SuggestPtrNullMut;
use crate::fn_ctxt::arg_matrix::{ArgMatrix, Compatibility, Error, ExpectedIdx, ProvidedIdx};
use crate::fn_ctxt::infer::FnCall;
use crate::gather_locals::Declaration;
+use crate::inline_asm::InlineAsmCtxt;
use crate::method::MethodCallee;
use crate::method::probe::IsSuggestion;
use crate::method::probe::Mode::MethodCall;
@@ -98,13 +98,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
debug!("FnCtxt::check_asm: {} deferred checks", deferred_asm_checks.len());
for (asm, hir_id) in deferred_asm_checks.drain(..) {
let enclosing_id = self.tcx.hir_enclosing_body_owner(hir_id);
- InlineAsmCtxt::new(
- enclosing_id,
- &self.infcx,
- self.typing_env(self.param_env),
- &*self.typeck_results.borrow(),
- )
- .check_asm(asm);
+ InlineAsmCtxt::new(self, enclosing_id).check_asm(asm);
}
}
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsicck.rs b/compiler/rustc_hir_typeck/src/inline_asm.rs
similarity index 89%
rename from compiler/rustc_hir_analysis/src/check/intrinsicck.rs
rename to compiler/rustc_hir_typeck/src/inline_asm.rs
index 32a582aadc1ca..6399f0a78ae2f 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsicck.rs
+++ b/compiler/rustc_hir_typeck/src/inline_asm.rs
@@ -3,25 +3,22 @@ use rustc_ast::InlineAsmTemplatePiece;
use rustc_data_structures::fx::FxIndexSet;
use rustc_hir::def_id::DefId;
use rustc_hir::{self as hir, LangItem};
-use rustc_infer::infer::InferCtxt;
use rustc_middle::bug;
-use rustc_middle::ty::{
- self, Article, FloatTy, IntTy, Ty, TyCtxt, TypeVisitableExt, TypeckResults, UintTy,
-};
+use rustc_middle::ty::{self, Article, FloatTy, IntTy, Ty, TyCtxt, TypeVisitableExt, UintTy};
use rustc_session::lint;
use rustc_span::def_id::LocalDefId;
-use rustc_span::{Symbol, sym};
+use rustc_span::{Span, Symbol, sym};
use rustc_target::asm::{
InlineAsmReg, InlineAsmRegClass, InlineAsmRegOrRegClass, InlineAsmType, ModifierInfo,
};
+use rustc_trait_selection::infer::InferCtxtExt;
+use crate::FnCtxt;
use crate::errors::RegisterTypeUnstable;
-pub struct InlineAsmCtxt<'a, 'tcx> {
- typing_env: ty::TypingEnv<'tcx>,
+pub(crate) struct InlineAsmCtxt<'a, 'tcx> {
target_features: &'tcx FxIndexSet<Symbol>,
- infcx: &'a InferCtxt<'tcx>,
- typeck_results: &'a TypeckResults<'tcx>,
+ fcx: &'a FnCtxt<'a, 'tcx>,
}
enum NonAsmTypeReason<'tcx> {
@@ -33,27 +30,17 @@ enum NonAsmTypeReason<'tcx> {
}
impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
- pub fn new(
- def_id: LocalDefId,
- infcx: &'a InferCtxt<'tcx>,
- typing_env: ty::TypingEnv<'tcx>,
- typeck_results: &'a TypeckResults<'tcx>,
- ) -> Self {
- InlineAsmCtxt {
- typing_env,
- target_features: infcx.tcx.asm_target_features(def_id),
- infcx,
- typeck_results,
- }
+ pub(crate) fn new(fcx: &'a FnCtxt<'a, 'tcx>, def_id: LocalDefId) -> Self {
+ InlineAsmCtxt { target_features: fcx.tcx.asm_target_features(def_id), fcx }
}
fn tcx(&self) -> TyCtxt<'tcx> {
- self.infcx.tcx
+ self.fcx.tcx
}
fn expr_ty(&self, expr: &hir::Expr<'tcx>) -> Ty<'tcx> {
- let ty = self.typeck_results.expr_ty_adjusted(expr);
- let ty = self.infcx.resolve_vars_if_possible(ty);
+ let ty = self.fcx.typeck_results.borrow().expr_ty_adjusted(expr);
+ let ty = self.fcx.try_structurally_resolve_type(expr.span, ty);
if ty.has_non_region_infer() {
Ty::new_misc_error(self.tcx())
} else {
@@ -62,19 +49,23 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
}
// FIXME(compiler-errors): This could use `<$ty as Pointee>::Metadata == ()`
- fn is_thin_ptr_ty(&self, ty: Ty<'tcx>) -> bool {
+ fn is_thin_ptr_ty(&self, span: Span, ty: Ty<'tcx>) -> bool {
// Type still may have region variables, but `Sized` does not depend
// on those, so just erase them before querying.
- if ty.is_sized(self.tcx(), self.typing_env) {
+ if self.fcx.type_is_sized_modulo_regions(self.fcx.param_env, ty) {
return true;
}
- if let ty::Foreign(..) = ty.kind() {
+ if let ty::Foreign(..) = self.fcx.try_structurally_resolve_type(span, ty).kind() {
return true;
}
false
}
- fn get_asm_ty(&self, ty: Ty<'tcx>) -> Result<InlineAsmType, NonAsmTypeReason<'tcx>> {
+ fn get_asm_ty(
+ &self,
+ span: Span,
+ ty: Ty<'tcx>,
+ ) -> Result<InlineAsmType, NonAsmTypeReason<'tcx>> {
let asm_ty_isize = match self.tcx().sess.target.pointer_width {
16 => InlineAsmType::I16,
32 => InlineAsmType::I32,
@@ -95,7 +86,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
ty::Float(FloatTy::F128) => Ok(InlineAsmType::F128),
ty::FnPtr(..) => Ok(asm_ty_isize),
ty::RawPtr(elem_ty, _) => {
- if self.is_thin_ptr_ty(elem_ty) {
+ if self.is_thin_ptr_ty(span, elem_ty) {
Ok(asm_ty_isize)
} else {
Err(NonAsmTypeReason::NotSizedPtr(ty))
@@ -109,11 +100,20 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
let field = &fields[FieldIdx::ZERO];
let elem_ty = field.ty(self.tcx(), args);
- let (size, ty) = match elem_ty.kind() {
+ let (size, ty) = match *elem_ty.kind() {
ty::Array(ty, len) => {
- let len = self.tcx().normalize_erasing_regions(self.typing_env, *len);
+ // FIXME: `try_structurally_resolve_const` doesn't eval consts
+ // in the old solver.
+ let len = if self.fcx.next_trait_solver() {
+ self.fcx.try_structurally_resolve_const(span, len)
+ } else {
+ self.fcx.tcx.normalize_erasing_regions(
+ self.fcx.typing_env(self.fcx.param_env),
+ len,
+ )
+ };
if let Some(len) = len.try_to_target_usize(self.tcx()) {
- (len, *ty)
+ (len, ty)
} else {
return Err(NonAsmTypeReason::UnevaluatedSIMDArrayLength(
field.did, len,
@@ -183,9 +183,9 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
);
let fields = &ty.non_enum_variant().fields;
let ty = fields[FieldIdx::ZERO].ty(self.tcx(), args);
- self.get_asm_ty(ty)
+ self.get_asm_ty(expr.span, ty)
}
- _ => self.get_asm_ty(ty),
+ _ => self.get_asm_ty(expr.span, ty),
};
let asm_ty = match asm_ty {
Ok(asm_ty) => asm_ty,
@@ -193,7 +193,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
match reason {
NonAsmTypeReason::UnevaluatedSIMDArrayLength(did, len) => {
let msg = format!("cannot evaluate SIMD vector length `{len}`");
- self.infcx
+ self.fcx
.dcx()
.struct_span_err(self.tcx().def_span(did), msg)
.with_span_note(
@@ -204,7 +204,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
}
NonAsmTypeReason::Invalid(ty) => {
let msg = format!("cannot use value of type `{ty}` for inline assembly");
- self.infcx.dcx().struct_span_err(expr.span, msg).with_note(
+ self.fcx.dcx().struct_span_err(expr.span, msg).with_note(
"only integers, floats, SIMD vectors, pointers and function pointers \
can be used as arguments for inline assembly",
).emit();
@@ -213,7 +213,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
let msg = format!(
"cannot use value of unsized pointer type `{ty}` for inline assembly"
);
- self.infcx
+ self.fcx
.dcx()
.struct_span_err(expr.span, msg)
.with_note("only sized pointers can be used in inline assembly")
@@ -223,7 +223,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
let msg = format!(
"cannot use SIMD vector with element type `{ty}` for inline assembly"
);
- self.infcx.dcx()
+ self.fcx.dcx()
.struct_span_err(self.tcx().def_span(did), msg).with_span_note(
expr.span,
"only integers, floats, SIMD vectors, pointers and function pointers \
@@ -232,7 +232,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
}
NonAsmTypeReason::EmptySIMDArray(ty) => {
let msg = format!("use of empty SIMD vector `{ty}`");
- self.infcx.dcx().struct_span_err(expr.span, msg).emit();
+ self.fcx.dcx().struct_span_err(expr.span, msg).emit();
}
}
return None;
@@ -241,9 +241,9 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
// Check that the type implements Copy. The only case where this can
// possibly fail is for SIMD types which don't #[derive(Copy)].
- if !self.tcx().type_is_copy_modulo_regions(self.typing_env, ty) {
+ if !self.fcx.type_is_copy_modulo_regions(self.fcx.param_env, ty) {
let msg = "arguments for inline assembly must be copyable";
- self.infcx
+ self.fcx
.dcx()
.struct_span_err(expr.span, msg)
.with_note(format!("`{ty}` does not implement the Copy trait"))
@@ -263,7 +263,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
if in_asm_ty != asm_ty {
let msg = "incompatible types for asm inout argument";
let in_expr_ty = self.expr_ty(in_expr);
- self.infcx
+ self.fcx
.dcx()
.struct_span_err(vec![in_expr.span, expr.span], msg)
.with_span_label(in_expr.span, format!("type `{in_expr_ty}`"))
@@ -296,7 +296,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
)
} else {
let msg = format!("type `{ty}` cannot be used with this register class");
- let mut err = self.infcx.dcx().struct_span_err(expr.span, msg);
+ let mut err = self.fcx.dcx().struct_span_err(expr.span, msg);
let supported_tys: Vec<_> =
supported_tys.iter().map(|(t, _)| t.to_string()).collect();
err.note(format!(
@@ -326,7 +326,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
if let Some(feature) = feature {
if !self.target_features.contains(feature) {
let msg = format!("`{feature}` target feature is not enabled");
- self.infcx
+ self.fcx
.dcx()
.struct_span_err(expr.span, msg)
.with_note(format!(
@@ -384,9 +384,9 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
Some(asm_ty)
}
- pub fn check_asm(&self, asm: &hir::InlineAsm<'tcx>) {
+ pub(crate) fn check_asm(&self, asm: &hir::InlineAsm<'tcx>) {
let Some(asm_arch) = self.tcx().sess.asm_arch else {
- self.infcx.dcx().delayed_bug("target architecture does not support asm");
+ self.fcx.dcx().delayed_bug("target architecture does not support asm");
return;
};
let allow_experimental_reg = self.tcx().features().asm_experimental_reg();
@@ -418,7 +418,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
op.is_clobber(),
) {
let msg = format!("cannot use register `{}`: {}", reg.name(), msg);
- self.infcx.dcx().span_err(op_sp, msg);
+ self.fcx.dcx().span_err(op_sp, msg);
continue;
}
}
@@ -458,7 +458,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
reg_class.name(),
feature
);
- self.infcx.dcx().span_err(op_sp, msg);
+ self.fcx.dcx().span_err(op_sp, msg);
// register isn't enabled, don't do more checks
continue;
}
@@ -472,7 +472,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
.intersperse(", ")
.collect::<String>(),
);
- self.infcx.dcx().span_err(op_sp, msg);
+ self.fcx.dcx().span_err(op_sp, msg);
// register isn't enabled, don't do more checks
continue;
}
@@ -512,7 +512,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
ty::Error(_) => {}
_ if ty.is_integral() => {}
_ => {
- self.infcx
+ self.fcx
.dcx()
.struct_span_err(op_sp, "invalid type for `const` operand")
.with_span_label(
@@ -531,7 +531,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
ty::FnDef(..) => {}
ty::Error(_) => {}
_ => {
- self.infcx
+ self.fcx
.dcx()
.struct_span_err(op_sp, "invalid `sym` operand")
.with_span_label(
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index c3717b4efa47f..d861a4f81b0e0 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -23,6 +23,7 @@ mod diverges;
mod errors;
mod expectation;
mod expr;
+mod inline_asm;
// Used by clippy;
pub mod expr_use_visitor;
mod fallback;
diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs
index c3a939f1ab086..4d346b50c8080 100644
--- a/compiler/rustc_interface/src/util.rs
+++ b/compiler/rustc_interface/src/util.rs
@@ -38,14 +38,25 @@ pub(crate) fn add_configuration(
codegen_backend: &dyn CodegenBackend,
) {
let tf = sym::target_feature;
+ let tf_cfg = codegen_backend.target_config(sess);
- let (target_features, unstable_target_features) = codegen_backend.target_features_cfg(sess);
+ sess.unstable_target_features.extend(tf_cfg.unstable_target_features.iter().copied());
+ sess.target_features.extend(tf_cfg.target_features.iter().copied());
- sess.unstable_target_features.extend(unstable_target_features.iter().copied());
+ cfg.extend(tf_cfg.target_features.into_iter().map(|feat| (tf, Some(feat))));
- sess.target_features.extend(target_features.iter().copied());
-
- cfg.extend(target_features.into_iter().map(|feat| (tf, Some(feat))));
+ if tf_cfg.has_reliable_f16 {
+ cfg.insert((sym::target_has_reliable_f16, None));
+ }
+ if tf_cfg.has_reliable_f16_math {
+ cfg.insert((sym::target_has_reliable_f16_math, None));
+ }
+ if tf_cfg.has_reliable_f128 {
+ cfg.insert((sym::target_has_reliable_f128, None));
+ }
+ if tf_cfg.has_reliable_f128_math {
+ cfg.insert((sym::target_has_reliable_f128_math, None));
+ }
if sess.crt_static(None) {
cfg.insert((tf, Some(sym::crt_dash_static)));
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 5f0e4d745e833..72369ab7b692a 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -973,6 +973,27 @@ extern "C" LLVMMetadataRef LLVMRustDIGetInstMetadata(LLVMValueRef x) {
return nullptr;
}
+extern "C" void
+LLVMRustRemoveEnumAttributeAtIndex(LLVMValueRef F, size_t index,
+ LLVMRustAttributeKind RustAttr) {
+ LLVMRemoveEnumAttributeAtIndex(F, index, fromRust(RustAttr));
+}
+
+extern "C" bool LLVMRustHasFnAttribute(LLVMValueRef F, const char *Name,
+ size_t NameLen) {
+ if (auto *Fn = dyn_cast<Function>(unwrap<Value>(F))) {
+ return Fn->hasFnAttribute(StringRef(Name, NameLen));
+ }
+ return false;
+}
+
+extern "C" void LLVMRustRemoveFnAttribute(LLVMValueRef Fn, const char *Name,
+ size_t NameLen) {
+ if (auto *F = dyn_cast<Function>(unwrap<Value>(Fn))) {
+ F->removeFnAttr(StringRef(Name, NameLen));
+ }
+}
+
extern "C" void LLVMRustGlobalAddMetadata(LLVMValueRef Global, unsigned Kind,
LLVMMetadataRef MD) {
unwrap<GlobalObject>(Global)->addMetadata(Kind, *unwrap<MDNode>(MD));
diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
index c168142fb1ecd..086ec529f33ae 100644
--- a/compiler/rustc_middle/src/thir.rs
+++ b/compiler/rustc_middle/src/thir.rs
@@ -799,7 +799,12 @@ pub enum PatKind<'tcx> {
/// Deref pattern, written `box P` for now.
DerefPattern {
subpattern: Box<Pat<'tcx>>,
- mutability: hir::Mutability,
+ /// Whether the pattern scrutinee needs to be borrowed in order to call `Deref::deref` or
+ /// `DerefMut::deref_mut`, and if so, which. This is `ByRef::No` for deref patterns on
+ /// boxes; they are lowered using a built-in deref rather than a method call, thus they
+ /// don't borrow the scrutinee.
+ #[type_visitable(ignore)]
+ borrow: ByRef,
},
/// One of the following:
diff --git a/compiler/rustc_middle/src/ty/typeck_results.rs b/compiler/rustc_middle/src/ty/typeck_results.rs
index 4c5c669771fb5..8c5827d36df1e 100644
--- a/compiler/rustc_middle/src/ty/typeck_results.rs
+++ b/compiler/rustc_middle/src/ty/typeck_results.rs
@@ -475,6 +475,21 @@ impl<'tcx> TypeckResults<'tcx> {
has_ref_mut
}
+ /// How should a deref pattern find the place for its inner pattern to match on?
+ ///
+ /// In most cases, if the pattern recursively contains a `ref mut` binding, we find the inner
+ /// pattern's scrutinee by calling `DerefMut::deref_mut`, and otherwise we call `Deref::deref`.
+ /// However, for boxes we can use a built-in deref instead, which doesn't borrow the scrutinee;
+ /// in this case, we return `ByRef::No`.
+ pub fn deref_pat_borrow_mode(&self, pointer_ty: Ty<'_>, inner: &hir::Pat<'_>) -> ByRef {
+ if pointer_ty.is_box() {
+ ByRef::No
+ } else {
+ let mutable = self.pat_has_ref_mut_binding(inner);
+ ByRef::Yes(if mutable { Mutability::Mut } else { Mutability::Not })
+ }
+ }
+
/// For a given closure, returns the iterator of `ty::CapturedPlace`s that are captured
/// by the closure.
pub fn closure_min_captures_flattened(
diff --git a/compiler/rustc_mir_build/src/builder/matches/match_pair.rs b/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
index d66b38c5b005c..3a7854a5e118d 100644
--- a/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
@@ -1,5 +1,6 @@
use std::sync::Arc;
+use rustc_hir::ByRef;
use rustc_middle::mir::*;
use rustc_middle::thir::*;
use rustc_middle::ty::{self, Ty, TypeVisitableExt};
@@ -260,7 +261,13 @@ impl<'tcx> MatchPairTree<'tcx> {
None
}
- PatKind::Deref { ref subpattern } => {
+ PatKind::Deref { ref subpattern }
+ | PatKind::DerefPattern { ref subpattern, borrow: ByRef::No } => {
+ if cfg!(debug_assertions) && matches!(pattern.kind, PatKind::DerefPattern { .. }) {
+ // Only deref patterns on boxes can be lowered using a built-in deref.
+ debug_assert!(pattern.ty.is_box());
+ }
+
MatchPairTree::for_pattern(
place_builder.deref(),
subpattern,
@@ -271,7 +278,7 @@ impl<'tcx> MatchPairTree<'tcx> {
None
}
- PatKind::DerefPattern { ref subpattern, mutability } => {
+ PatKind::DerefPattern { ref subpattern, borrow: ByRef::Yes(mutability) } => {
// Create a new temporary for each deref pattern.
// FIXME(deref_patterns): dedup temporaries to avoid multiple `deref()` calls?
let temp = cx.temp(
diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
index 8f058efdfacdb..8e69ff568b928 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@@ -111,10 +111,8 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
let kind = match adjust.kind {
PatAdjust::BuiltinDeref => PatKind::Deref { subpattern: thir_pat },
PatAdjust::OverloadedDeref => {
- let mutable = self.typeck_results.pat_has_ref_mut_binding(pat);
- let mutability =
- if mutable { hir::Mutability::Mut } else { hir::Mutability::Not };
- PatKind::DerefPattern { subpattern: thir_pat, mutability }
+ let borrow = self.typeck_results.deref_pat_borrow_mode(adjust.source, pat);
+ PatKind::DerefPattern { subpattern: thir_pat, borrow }
}
};
Box::new(Pat { span, ty: adjust.source, kind })
@@ -308,9 +306,8 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
}
hir::PatKind::Deref(subpattern) => {
- let mutable = self.typeck_results.pat_has_ref_mut_binding(subpattern);
- let mutability = if mutable { hir::Mutability::Mut } else { hir::Mutability::Not };
- PatKind::DerefPattern { subpattern: self.lower_pattern(subpattern), mutability }
+ let borrow = self.typeck_results.deref_pat_borrow_mode(ty, subpattern);
+ PatKind::DerefPattern { subpattern: self.lower_pattern(subpattern), borrow }
}
hir::PatKind::Ref(subpattern, _) => {
// Track the default binding mode for the Rust 2024 migration suggestion.
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
index 04f80a056f94d..dded84f67686b 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
@@ -81,12 +81,19 @@ where
/// the values inferred while solving the instantiated goal.
/// - `external_constraints`: additional constraints which aren't expressible
/// using simple unification of inference variables.
+ ///
+ /// This takes the `shallow_certainty` which represents whether we're confident
+ /// that the final result of the current goal only depends on the nested goals.
+ ///
+ /// In case this is `Certainy::Maybe`, there may still be additional nested goals
+ /// or inference constraints required for this candidate to be hold. The candidate
+ /// always requires all already added constraints and nested goals.
#[instrument(level = "trace", skip(self), ret)]
pub(in crate::solve) fn evaluate_added_goals_and_make_canonical_response(
&mut self,
- certainty: Certainty,
+ shallow_certainty: Certainty,
) -> QueryResult<I> {
- self.inspect.make_canonical_response(certainty);
+ self.inspect.make_canonical_response(shallow_certainty);
let goals_certainty = self.try_evaluate_added_goals()?;
assert_eq!(
@@ -103,26 +110,29 @@ where
NoSolution
})?;
- // When normalizing, we've replaced the expected term with an unconstrained
- // inference variable. This means that we dropped information which could
- // have been important. We handle this by instead returning the nested goals
- // to the caller, where they are then handled.
- //
- // As we return all ambiguous nested goals, we can ignore the certainty returned
- // by `try_evaluate_added_goals()`.
- let (certainty, normalization_nested_goals) = match self.current_goal_kind {
- CurrentGoalKind::NormalizesTo => {
- let goals = std::mem::take(&mut self.nested_goals);
- if goals.is_empty() {
- assert!(matches!(goals_certainty, Certainty::Yes));
+ let (certainty, normalization_nested_goals) =
+ match (self.current_goal_kind, shallow_certainty) {
+ // When normalizing, we've replaced the expected term with an unconstrained
+ // inference variable. This means that we dropped information which could
+ // have been important. We handle this by instead returning the nested goals
+ // to the caller, where they are then handled. We only do so if we do not
+ // need to recompute the `NormalizesTo` goal afterwards to avoid repeatedly
+ // uplifting its nested goals. This is the case if the `shallow_certainty` is
+ // `Certainty::Yes`.
+ (CurrentGoalKind::NormalizesTo, Certainty::Yes) => {
+ let goals = std::mem::take(&mut self.nested_goals);
+ // As we return all ambiguous nested goals, we can ignore the certainty
+ // returned by `self.try_evaluate_added_goals()`.
+ if goals.is_empty() {
+ assert!(matches!(goals_certainty, Certainty::Yes));
+ }
+ (Certainty::Yes, NestedNormalizationGoals(goals))
}
- (certainty, NestedNormalizationGoals(goals))
- }
- CurrentGoalKind::Misc | CurrentGoalKind::CoinductiveTrait => {
- let certainty = certainty.unify_with(goals_certainty);
- (certainty, NestedNormalizationGoals::empty())
- }
- };
+ _ => {
+ let certainty = shallow_certainty.unify_with(goals_certainty);
+ (certainty, NestedNormalizationGoals::empty())
+ }
+ };
if let Certainty::Maybe(cause @ MaybeCause::Overflow { .. }) = certainty {
// If we have overflow, it's probable that we're substituting a type
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
index f5cad623903fc..b030af483817e 100644
--- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
@@ -6,7 +6,7 @@ mod opaque_types;
use rustc_type_ir::fast_reject::DeepRejectCtxt;
use rustc_type_ir::inherent::*;
use rustc_type_ir::lang_items::TraitSolverLangItem;
-use rustc_type_ir::{self as ty, Interner, NormalizesTo, Upcast as _};
+use rustc_type_ir::{self as ty, Interner, NormalizesTo, PredicateKind, Upcast as _};
use tracing::instrument;
use crate::delegate::SolverDelegate;
@@ -194,6 +194,12 @@ where
.map(|pred| goal.with(cx, pred));
ecx.add_goals(GoalSource::ImplWhereBound, where_clause_bounds);
+ // Bail if the nested goals don't hold here. This is to avoid unnecessarily
+ // computing the `type_of` query for associated types that never apply, as
+ // this may result in query cycles in the case of RPITITs.
+ // See <https://github.com/rust-lang/trait-system-refactor-initiative/issues/185>.
+ ecx.try_evaluate_added_goals()?;
+
// Add GAT where clauses from the trait's definition.
// FIXME: We don't need these, since these are the type's own WF obligations.
ecx.add_goals(
@@ -221,13 +227,21 @@ where
Ok(Some(target_item_def_id)) => target_item_def_id,
Ok(None) => {
match ecx.typing_mode() {
- // In case the associated item is hidden due to specialization, we have to
- // return ambiguity this would otherwise be incomplete, resulting in
- // unsoundness during coherence (#105782).
+ // In case the associated item is hidden due to specialization,
+ // normalizing this associated item is always ambiguous. Treating
+ // the associated item as rigid would be incomplete and allow for
+ // overlapping impls, see #105782.
+ //
+ // As this ambiguity is unavoidable we emit a nested ambiguous
+ // goal instead of using `Certainty::AMBIGUOUS`. This allows us to
+ // return the nested goals to the parent `AliasRelate` goal. This
+ // would be relevant if any of the nested goals refer to the `term`.
+ // This is not the case here and we only prefer adding an ambiguous
+ // nested goal for consistency.
ty::TypingMode::Coherence => {
- return ecx.evaluate_added_goals_and_make_canonical_response(
- Certainty::AMBIGUOUS,
- );
+ ecx.add_goal(GoalSource::Misc, goal.with(cx, PredicateKind::Ambiguous));
+ return ecx
+ .evaluate_added_goals_and_make_canonical_response(Certainty::Yes);
}
// Outside of coherence, we treat the associated item as rigid instead.
ty::TypingMode::Analysis { .. }
@@ -254,10 +268,20 @@ where
// treat it as rigid.
if cx.impl_self_is_guaranteed_unsized(impl_def_id) {
match ecx.typing_mode() {
+ // Trying to normalize such associated items is always ambiguous
+ // during coherence to avoid cyclic reasoning. See the example in
+ // tests/ui/traits/trivial-unsized-projection-in-coherence.rs.
+ //
+ // As this ambiguity is unavoidable we emit a nested ambiguous
+ // goal instead of using `Certainty::AMBIGUOUS`. This allows us to
+ // return the nested goals to the parent `AliasRelate` goal. This
+ // would be relevant if any of the nested goals refer to the `term`.
+ // This is not the case here and we only prefer adding an ambiguous
+ // nested goal for consistency.
ty::TypingMode::Coherence => {
- return ecx.evaluate_added_goals_and_make_canonical_response(
- Certainty::AMBIGUOUS,
- );
+ ecx.add_goal(GoalSource::Misc, goal.with(cx, PredicateKind::Ambiguous));
+ return ecx
+ .evaluate_added_goals_and_make_canonical_response(Certainty::Yes);
}
ty::TypingMode::Analysis { .. }
| ty::TypingMode::Borrowck { .. }
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/opaque_types.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/opaque_types.rs
index ee439f1b3d0d5..df3ad1e468bb8 100644
--- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/opaque_types.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/opaque_types.rs
@@ -3,6 +3,7 @@
use rustc_index::bit_set::GrowableBitSet;
use rustc_type_ir::inherent::*;
+use rustc_type_ir::solve::GoalSource;
use rustc_type_ir::{self as ty, Interner, TypingMode, fold_regions};
use crate::delegate::SolverDelegate;
@@ -31,7 +32,12 @@ where
goal.param_env,
expected,
);
- self.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
+ // Trying to normalize an opaque type during coherence is always ambiguous.
+ // We add a nested ambiguous goal here instead of using `Certainty::AMBIGUOUS`.
+ // This allows us to return the nested goals to the parent `AliasRelate` goal.
+ // This can then allow nested goals to fail after we've constrained the `term`.
+ self.add_goal(GoalSource::Misc, goal.with(cx, ty::PredicateKind::Ambiguous));
+ self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
}
TypingMode::Analysis { defining_opaque_types_and_generators } => {
let Some(def_id) = opaque_ty
diff --git a/compiler/rustc_session/src/config/cfg.rs b/compiler/rustc_session/src/config/cfg.rs
index 231ca434962e6..cbfe9e0da6adf 100644
--- a/compiler/rustc_session/src/config/cfg.rs
+++ b/compiler/rustc_session/src/config/cfg.rs
@@ -142,6 +142,10 @@ pub(crate) fn disallow_cfgs(sess: &Session, user_cfgs: &Cfg) {
| (sym::target_has_atomic, Some(_))
| (sym::target_has_atomic_equal_alignment, Some(_))
| (sym::target_has_atomic_load_store, Some(_))
+ | (sym::target_has_reliable_f16, None | Some(_))
+ | (sym::target_has_reliable_f16_math, None | Some(_))
+ | (sym::target_has_reliable_f128, None | Some(_))
+ | (sym::target_has_reliable_f128_math, None | Some(_))
| (sym::target_thread_local, None) => disallow(cfg, "--target"),
(sym::fmt_debug, None | Some(_)) => disallow(cfg, "-Z fmt-debug"),
(sym::emscripten_wasm_eh, None | Some(_)) => disallow(cfg, "-Z emscripten_wasm_eh"),
diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
index fccdaed21a20b..9722031f209b5 100644
--- a/compiler/rustc_span/src/lib.rs
+++ b/compiler/rustc_span/src/lib.rs
@@ -31,7 +31,6 @@
#![feature(round_char_boundary)]
#![feature(rustc_attrs)]
#![feature(rustdoc_internals)]
-#![feature(slice_as_chunks)]
// tidy-alphabetical-end
// The code produced by the `Encodable`/`Decodable` derive macros refer to
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 040ea7d8bc219..ba3e6d7ca826c 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -614,6 +614,7 @@ symbols! {
cfg_target_feature,
cfg_target_has_atomic,
cfg_target_has_atomic_equal_alignment,
+ cfg_target_has_reliable_f16_f128,
cfg_target_thread_local,
cfg_target_vendor,
cfg_trace: "<cfg>", // must not be a valid identifier
@@ -2068,6 +2069,10 @@ symbols! {
target_has_atomic,
target_has_atomic_equal_alignment,
target_has_atomic_load_store,
+ target_has_reliable_f128,
+ target_has_reliable_f128_math,
+ target_has_reliable_f16,
+ target_has_reliable_f16_math,
target_os,
target_pointer_width,
target_thread_local,
diff --git a/library/alloc/src/vec/into_iter.rs b/library/alloc/src/vec/into_iter.rs
index 3eee988b6c9d1..1af110691ba64 100644
--- a/library/alloc/src/vec/into_iter.rs
+++ b/library/alloc/src/vec/into_iter.rs
@@ -168,7 +168,7 @@ impl<T, A: Allocator> IntoIter<T, A> {
// SAFETY: This allocation originally came from a `Vec`, so it passes
// all those checks. We have `this.buf` ≤ `this.ptr` ≤ `this.end`,
- // so the `sub_ptr`s below cannot wrap, and will produce a well-formed
+ // so the `offset_from_unsigned`s below cannot wrap, and will produce a well-formed
// range. `end` ≤ `buf + cap`, so the range will be in-bounds.
// Taking `alloc` is ok because nothing else is going to look at it,
// since our `Drop` impl isn't going to run so there's no more code.
diff --git a/library/alloc/src/vec/splice.rs b/library/alloc/src/vec/splice.rs
index ca5cb17f8bfda..ed1a0dda76d29 100644
--- a/library/alloc/src/vec/splice.rs
+++ b/library/alloc/src/vec/splice.rs
@@ -59,7 +59,7 @@ impl<I: Iterator, A: Allocator> Drop for Splice<'_, I, A> {
// and moving things into the final place.
// Which means we can replace the slice::Iter with pointers that won't point to deallocated
// memory, so that Drain::drop is still allowed to call iter.len(), otherwise it would break
- // the ptr.sub_ptr contract.
+ // the ptr.offset_from_unsigned contract.
self.drain.iter = (&[]).iter();
unsafe {
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index a7563f918a241..c5d5bc000f1c7 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -2996,7 +2996,7 @@ pub unsafe fn nontemporal_store<T>(ptr: *mut T, val: T);
#[rustc_intrinsic]
pub const unsafe fn ptr_offset_from<T>(ptr: *const T, base: *const T) -> isize;
-/// See documentation of `<*const T>::sub_ptr` for details.
+/// See documentation of `<*const T>::offset_from_unsigned` for details.
#[rustc_nounwind]
#[rustc_intrinsic]
#[rustc_intrinsic_const_stable_indirect]
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 9625475e617ea..64a7ec8906b6b 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -118,7 +118,6 @@
#![feature(ptr_metadata)]
#![feature(set_ptr_value)]
#![feature(slice_as_array)]
-#![feature(slice_as_chunks)]
#![feature(slice_ptr_get)]
#![feature(str_internals)]
#![feature(str_split_inclusive_remainder)]
diff --git a/library/core/src/ptr/const_ptr.rs b/library/core/src/ptr/const_ptr.rs
index 2d869958b85cc..bcf34781c8acd 100644
--- a/library/core/src/ptr/const_ptr.rs
+++ b/library/core/src/ptr/const_ptr.rs
@@ -804,8 +804,8 @@ impl<T: ?Sized> *const T {
/// units of **bytes**.
///
/// This is purely a convenience for casting to a `u8` pointer and
- /// using [`sub_ptr`][pointer::offset_from_unsigned] on it. See that method for
- /// documentation and safety requirements.
+ /// using [`offset_from_unsigned`][pointer::offset_from_unsigned] on it.
+ /// See that method for documentation and safety requirements.
///
/// For non-`Sized` pointees this operation considers only the data pointers,
/// ignoring the metadata.
@@ -814,7 +814,7 @@ impl<T: ?Sized> *const T {
#[inline]
#[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
pub const unsafe fn byte_offset_from_unsigned<U: ?Sized>(self, origin: *const U) -> usize {
- // SAFETY: the caller must uphold the safety contract for `sub_ptr`.
+ // SAFETY: the caller must uphold the safety contract for `offset_from_unsigned`.
unsafe { self.cast::<u8>().offset_from_unsigned(origin.cast::<u8>()) }
}
diff --git a/library/core/src/ptr/mut_ptr.rs b/library/core/src/ptr/mut_ptr.rs
index df49eedb35096..6d1a50d84366e 100644
--- a/library/core/src/ptr/mut_ptr.rs
+++ b/library/core/src/ptr/mut_ptr.rs
@@ -937,6 +937,7 @@ impl<T: ?Sized> *mut T {
///
/// // This would be incorrect, as the pointers are not correctly ordered:
/// // ptr1.offset_from(ptr2)
+ /// ```
#[stable(feature = "ptr_sub_ptr", since = "1.87.0")]
#[rustc_const_stable(feature = "const_ptr_sub_ptr", since = "1.87.0")]
#[inline]
@@ -945,7 +946,7 @@ impl<T: ?Sized> *mut T {
where
T: Sized,
{
- // SAFETY: the caller must uphold the safety contract for `sub_ptr`.
+ // SAFETY: the caller must uphold the safety contract for `offset_from_unsigned`.
unsafe { (self as *const T).offset_from_unsigned(origin) }
}
@@ -954,8 +955,8 @@ impl<T: ?Sized> *mut T {
/// units of **bytes**.
///
/// This is purely a convenience for casting to a `u8` pointer and
- /// using [`sub_ptr`][pointer::offset_from_unsigned] on it. See that method for
- /// documentation and safety requirements.
+ /// using [`offset_from_unsigned`][pointer::offset_from_unsigned] on it.
+ /// See that method for documentation and safety requirements.
///
/// For non-`Sized` pointees this operation considers only the data pointers,
/// ignoring the metadata.
@@ -964,7 +965,7 @@ impl<T: ?Sized> *mut T {
#[inline]
#[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
pub const unsafe fn byte_offset_from_unsigned<U: ?Sized>(self, origin: *mut U) -> usize {
- // SAFETY: the caller must uphold the safety contract for `byte_sub_ptr`.
+ // SAFETY: the caller must uphold the safety contract for `byte_offset_from_unsigned`.
unsafe { (self as *const T).byte_offset_from_unsigned(origin) }
}
diff --git a/library/core/src/ptr/non_null.rs b/library/core/src/ptr/non_null.rs
index 68b8f0c3e4e1d..0864cc457b658 100644
--- a/library/core/src/ptr/non_null.rs
+++ b/library/core/src/ptr/non_null.rs
@@ -906,7 +906,7 @@ impl<T: ?Sized> NonNull<T> {
where
T: Sized,
{
- // SAFETY: the caller must uphold the safety contract for `sub_ptr`.
+ // SAFETY: the caller must uphold the safety contract for `offset_from_unsigned`.
unsafe { self.as_ptr().offset_from_unsigned(subtracted.as_ptr()) }
}
@@ -915,8 +915,8 @@ impl<T: ?Sized> NonNull<T> {
/// units of **bytes**.
///
/// This is purely a convenience for casting to a `u8` pointer and
- /// using [`sub_ptr`][NonNull::offset_from_unsigned] on it. See that method for
- /// documentation and safety requirements.
+ /// using [`offset_from_unsigned`][NonNull::offset_from_unsigned] on it.
+ /// See that method for documentation and safety requirements.
///
/// For non-`Sized` pointees this operation considers only the data pointers,
/// ignoring the metadata.
@@ -925,7 +925,7 @@ impl<T: ?Sized> NonNull<T> {
#[stable(feature = "ptr_sub_ptr", since = "1.87.0")]
#[rustc_const_stable(feature = "const_ptr_sub_ptr", since = "1.87.0")]
pub const unsafe fn byte_offset_from_unsigned<U: ?Sized>(self, origin: NonNull<U>) -> usize {
- // SAFETY: the caller must uphold the safety contract for `byte_sub_ptr`.
+ // SAFETY: the caller must uphold the safety contract for `byte_offset_from_unsigned`.
unsafe { self.as_ptr().byte_offset_from_unsigned(origin.as_ptr()) }
}
diff --git a/library/core/src/slice/iter.rs b/library/core/src/slice/iter.rs
index f507ee563ac07..85a5e89a49eb3 100644
--- a/library/core/src/slice/iter.rs
+++ b/library/core/src/slice/iter.rs
@@ -2335,7 +2335,6 @@ pub struct ArrayChunks<'a, T: 'a, const N: usize> {
impl<'a, T, const N: usize> ArrayChunks<'a, T, N> {
#[rustc_const_unstable(feature = "const_slice_make_iter", issue = "137737")]
- // #[rustc_const_unstable(feature = "slice_as_chunks", issue = "74985")]
#[inline]
pub(super) const fn new(slice: &'a [T]) -> Self {
let (array_slice, rem) = slice.as_chunks();
diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
index fbfa4d874158b..81fe0166fd77b 100644
--- a/library/core/src/slice/mod.rs
+++ b/library/core/src/slice/mod.rs
@@ -1268,6 +1268,18 @@ impl<T> [T] {
/// Splits the slice into a slice of `N`-element arrays,
/// assuming that there's no remainder.
///
+ /// This is the inverse operation to [`as_flattened`].
+ ///
+ /// [`as_flattened`]: slice::as_flattened
+ ///
+ /// As this is `unsafe`, consider whether you could use [`as_chunks`] or
+ /// [`as_rchunks`] instead, perhaps via something like
+ /// `if let (chunks, []) = slice.as_chunks()` or
+ /// `let (chunks, []) = slice.as_chunks() else { unreachable!() };`.
+ ///
+ /// [`as_chunks`]: slice::as_chunks
+ /// [`as_rchunks`]: slice::as_rchunks
+ ///
/// # Safety
///
/// This may only be called when
@@ -1277,7 +1289,6 @@ impl<T> [T] {
/// # Examples
///
/// ```
- /// #![feature(slice_as_chunks)]
/// let slice: &[char] = &['l', 'o', 'r', 'e', 'm', '!'];
/// let chunks: &[[char; 1]] =
/// // SAFETY: 1-element chunks never have remainder
@@ -1292,7 +1303,8 @@ impl<T> [T] {
/// // let chunks: &[[_; 5]] = slice.as_chunks_unchecked() // The slice length is not a multiple of 5
/// // let chunks: &[[_; 0]] = slice.as_chunks_unchecked() // Zero-length chunks are never allowed
/// ```
- #[unstable(feature = "slice_as_chunks", issue = "74985")]
+ #[stable(feature = "slice_as_chunks", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "slice_as_chunks", since = "CURRENT_RUSTC_VERSION")]
#[inline]
#[must_use]
pub const unsafe fn as_chunks_unchecked<const N: usize>(&self) -> &[[T; N]] {
@@ -1312,15 +1324,27 @@ impl<T> [T] {
/// starting at the beginning of the slice,
/// and a remainder slice with length strictly less than `N`.
///
+ /// The remainder is meaningful in the division sense. Given
+ /// `let (chunks, remainder) = slice.as_chunks()`, then:
+ /// - `chunks.len()` equals `slice.len() / N`,
+ /// - `remainder.len()` equals `slice.len() % N`, and
+ /// - `slice.len()` equals `chunks.len() * N + remainder.len()`.
+ ///
+ /// You can flatten the chunks back into a slice-of-`T` with [`as_flattened`].
+ ///
+ /// [`as_flattened`]: slice::as_flattened
+ ///
/// # Panics
///
- /// Panics if `N` is zero. This check will most probably get changed to a compile time
- /// error before this method gets stabilized.
+ /// Panics if `N` is zero.
+ ///
+ /// Note that this check is against a const generic parameter, not a runtime
+ /// value, and thus a particular monomorphization will either always panic
+ /// or it will never panic.
///
/// # Examples
///
/// ```
- /// #![feature(slice_as_chunks)]
/// let slice = ['l', 'o', 'r', 'e', 'm'];
/// let (chunks, remainder) = slice.as_chunks();
/// assert_eq!(chunks, &[['l', 'o'], ['r', 'e']]);
@@ -1330,14 +1354,14 @@ impl<T> [T] {
/// If you expect the slice to be an exact multiple, you can combine
/// `let`-`else` with an empty slice pattern:
/// ```
- /// #![feature(slice_as_chunks)]
/// let slice = ['R', 'u', 's', 't'];
/// let (chunks, []) = slice.as_chunks::<2>() else {
/// panic!("slice didn't have even length")
/// };
/// assert_eq!(chunks, &[['R', 'u'], ['s', 't']]);
/// ```
- #[unstable(feature = "slice_as_chunks", issue = "74985")]
+ #[stable(feature = "slice_as_chunks", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "slice_as_chunks", since = "CURRENT_RUSTC_VERSION")]
#[inline]
#[track_caller]
#[must_use]
@@ -1357,21 +1381,34 @@ impl<T> [T] {
/// starting at the end of the slice,
/// and a remainder slice with length strictly less than `N`.
///
+ /// The remainder is meaningful in the division sense. Given
+ /// `let (remainder, chunks) = slice.as_rchunks()`, then:
+ /// - `remainder.len()` equals `slice.len() % N`,
+ /// - `chunks.len()` equals `slice.len() / N`, and
+ /// - `slice.len()` equals `chunks.len() * N + remainder.len()`.
+ ///
+ /// You can flatten the chunks back into a slice-of-`T` with [`as_flattened`].
+ ///
+ /// [`as_flattened`]: slice::as_flattened
+ ///
/// # Panics
///
- /// Panics if `N` is zero. This check will most probably get changed to a compile time
- /// error before this method gets stabilized.
+ /// Panics if `N` is zero.
+ ///
+ /// Note that this check is against a const generic parameter, not a runtime
+ /// value, and thus a particular monomorphization will either always panic
+ /// or it will never panic.
///
/// # Examples
///
/// ```
- /// #![feature(slice_as_chunks)]
/// let slice = ['l', 'o', 'r', 'e', 'm'];
/// let (remainder, chunks) = slice.as_rchunks();
/// assert_eq!(remainder, &['l']);
/// assert_eq!(chunks, &[['o', 'r'], ['e', 'm']]);
/// ```
- #[unstable(feature = "slice_as_chunks", issue = "74985")]
+ #[stable(feature = "slice_as_chunks", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "slice_as_chunks", since = "CURRENT_RUSTC_VERSION")]
#[inline]
#[track_caller]
#[must_use]
@@ -1424,6 +1461,18 @@ impl<T> [T] {
/// Splits the slice into a slice of `N`-element arrays,
/// assuming that there's no remainder.
///
+ /// This is the inverse operation to [`as_flattened_mut`].
+ ///
+ /// [`as_flattened_mut`]: slice::as_flattened_mut
+ ///
+ /// As this is `unsafe`, consider whether you could use [`as_chunks_mut`] or
+ /// [`as_rchunks_mut`] instead, perhaps via something like
+ /// `if let (chunks, []) = slice.as_chunks_mut()` or
+ /// `let (chunks, []) = slice.as_chunks_mut() else { unreachable!() };`.
+ ///
+ /// [`as_chunks_mut`]: slice::as_chunks_mut
+ /// [`as_rchunks_mut`]: slice::as_rchunks_mut
+ ///
/// # Safety
///
/// This may only be called when
@@ -1433,7 +1482,6 @@ impl<T> [T] {
/// # Examples
///
/// ```
- /// #![feature(slice_as_chunks)]
/// let slice: &mut [char] = &mut ['l', 'o', 'r', 'e', 'm', '!'];
/// let chunks: &mut [[char; 1]] =
/// // SAFETY: 1-element chunks never have remainder
@@ -1450,7 +1498,8 @@ impl<T> [T] {
/// // let chunks: &[[_; 5]] = slice.as_chunks_unchecked_mut() // The slice length is not a multiple of 5
/// // let chunks: &[[_; 0]] = slice.as_chunks_unchecked_mut() // Zero-length chunks are never allowed
/// ```
- #[unstable(feature = "slice_as_chunks", issue = "74985")]
+ #[stable(feature = "slice_as_chunks", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "slice_as_chunks", since = "CURRENT_RUSTC_VERSION")]
#[inline]
#[must_use]
pub const unsafe fn as_chunks_unchecked_mut<const N: usize>(&mut self) -> &mut [[T; N]] {
@@ -1470,15 +1519,27 @@ impl<T> [T] {
/// starting at the beginning of the slice,
/// and a remainder slice with length strictly less than `N`.
///
+ /// The remainder is meaningful in the division sense. Given
+ /// `let (chunks, remainder) = slice.as_chunks_mut()`, then:
+ /// - `chunks.len()` equals `slice.len() / N`,
+ /// - `remainder.len()` equals `slice.len() % N`, and
+ /// - `slice.len()` equals `chunks.len() * N + remainder.len()`.
+ ///
+ /// You can flatten the chunks back into a slice-of-`T` with [`as_flattened_mut`].
+ ///
+ /// [`as_flattened_mut`]: slice::as_flattened_mut
+ ///
/// # Panics
///
- /// Panics if `N` is zero. This check will most probably get changed to a compile time
- /// error before this method gets stabilized.
+ /// Panics if `N` is zero.
+ ///
+ /// Note that this check is against a const generic parameter, not a runtime
+ /// value, and thus a particular monomorphization will either always panic
+ /// or it will never panic.
///
/// # Examples
///
/// ```
- /// #![feature(slice_as_chunks)]
/// let v = &mut [0, 0, 0, 0, 0];
/// let mut count = 1;
///
@@ -1490,7 +1551,8 @@ impl<T> [T] {
/// }
/// assert_eq!(v, &[1, 1, 2, 2, 9]);
/// ```
- #[unstable(feature = "slice_as_chunks", issue = "74985")]
+ #[stable(feature = "slice_as_chunks", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "slice_as_chunks", since = "CURRENT_RUSTC_VERSION")]
#[inline]
#[track_caller]
#[must_use]
@@ -1510,15 +1572,27 @@ impl<T> [T] {
/// starting at the end of the slice,
/// and a remainder slice with length strictly less than `N`.
///
+ /// The remainder is meaningful in the division sense. Given
+ /// `let (remainder, chunks) = slice.as_rchunks_mut()`, then:
+ /// - `remainder.len()` equals `slice.len() % N`,
+ /// - `chunks.len()` equals `slice.len() / N`, and
+ /// - `slice.len()` equals `chunks.len() * N + remainder.len()`.
+ ///
+ /// You can flatten the chunks back into a slice-of-`T` with [`as_flattened_mut`].
+ ///
+ /// [`as_flattened_mut`]: slice::as_flattened_mut
+ ///
/// # Panics
///
- /// Panics if `N` is zero. This check will most probably get changed to a compile time
- /// error before this method gets stabilized.
+ /// Panics if `N` is zero.
+ ///
+ /// Note that this check is against a const generic parameter, not a runtime
+ /// value, and thus a particular monomorphization will either always panic
+ /// or it will never panic.
///
/// # Examples
///
/// ```
- /// #![feature(slice_as_chunks)]
/// let v = &mut [0, 0, 0, 0, 0];
/// let mut count = 1;
///
@@ -1530,7 +1604,8 @@ impl<T> [T] {
/// }
/// assert_eq!(v, &[9, 1, 1, 2, 2]);
/// ```
- #[unstable(feature = "slice_as_chunks", issue = "74985")]
+ #[stable(feature = "slice_as_chunks", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "slice_as_chunks", since = "CURRENT_RUSTC_VERSION")]
#[inline]
#[track_caller]
#[must_use]
@@ -4816,6 +4891,11 @@ impl<T> [MaybeUninit<T>] {
impl<T, const N: usize> [[T; N]] {
/// Takes a `&[[T; N]]`, and flattens it to a `&[T]`.
///
+ /// For the opposite operation, see [`as_chunks`] and [`as_rchunks`].
+ ///
+ /// [`as_chunks`]: slice::as_chunks
+ /// [`as_rchunks`]: slice::as_rchunks
+ ///
/// # Panics
///
/// This panics if the length of the resulting slice would overflow a `usize`.
@@ -4856,6 +4936,11 @@ impl<T, const N: usize> [[T; N]] {
/// Takes a `&mut [[T; N]]`, and flattens it to a `&mut [T]`.
///
+ /// For the opposite operation, see [`as_chunks_mut`] and [`as_rchunks_mut`].
+ ///
+ /// [`as_chunks_mut`]: slice::as_chunks_mut
+ /// [`as_rchunks_mut`]: slice::as_rchunks_mut
+ ///
/// # Panics
///
/// This panics if the length of the resulting slice would overflow a `usize`.
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index 602af4a0447ee..940b671c51461 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -163,4 +163,10 @@ check-cfg = [
# and to the `backtrace` crate which messes-up with Cargo list
# of declared features, we therefor expect any feature cfg
'cfg(feature, values(any()))',
+ # Internal features aren't marked known config by default, we use these to
+ # gate tests.
+ 'cfg(target_has_reliable_f16)',
+ 'cfg(target_has_reliable_f16_math)',
+ 'cfg(target_has_reliable_f128)',
+ 'cfg(target_has_reliable_f128_math)',
]
diff --git a/library/std/build.rs b/library/std/build.rs
index 40a56d4930d35..ef695601a448a 100644
--- a/library/std/build.rs
+++ b/library/std/build.rs
@@ -7,12 +7,6 @@ fn main() {
let target_vendor =
env::var("CARGO_CFG_TARGET_VENDOR").expect("CARGO_CFG_TARGET_VENDOR was not set");
let target_env = env::var("CARGO_CFG_TARGET_ENV").expect("CARGO_CFG_TARGET_ENV was not set");
- let target_abi = env::var("CARGO_CFG_TARGET_ABI").expect("CARGO_CFG_TARGET_ABI was not set");
- let target_pointer_width: u32 = env::var("CARGO_CFG_TARGET_POINTER_WIDTH")
- .expect("CARGO_CFG_TARGET_POINTER_WIDTH was not set")
- .parse()
- .unwrap();
- let is_miri = env::var_os("CARGO_CFG_MIRI").is_some();
println!("cargo:rustc-check-cfg=cfg(netbsd10)");
if target_os == "netbsd" && env::var("RUSTC_STD_NETBSD10").is_ok() {
@@ -80,108 +74,4 @@ fn main() {
println!("cargo:rustc-cfg=backtrace_in_libstd");
println!("cargo:rustc-env=STD_ENV_ARCH={}", env::var("CARGO_CFG_TARGET_ARCH").unwrap());
-
- // Emit these on platforms that have no known ABI bugs, LLVM selection bugs, lowering bugs,
- // missing symbols, or other problems, to determine when tests get run.
- // If more broken platforms are found, please update the tracking issue at
- // <https://github.com/rust-lang/rust/issues/116909>
- //
- // Some of these match arms are redundant; the goal is to separate reasons that the type is
- // unreliable, even when multiple reasons might fail the same platform.
- println!("cargo:rustc-check-cfg=cfg(reliable_f16)");
- println!("cargo:rustc-check-cfg=cfg(reliable_f128)");
-
- // This is a step beyond only having the types and basic functions available. Math functions
- // aren't consistently available or correct.
- println!("cargo:rustc-check-cfg=cfg(reliable_f16_math)");
- println!("cargo:rustc-check-cfg=cfg(reliable_f128_math)");
-
- let has_reliable_f16 = match (target_arch.as_str(), target_os.as_str()) {
- // We can always enable these in Miri as that is not affected by codegen bugs.
- _ if is_miri => true,
- // Selection failure <https://github.com/llvm/llvm-project/issues/50374>
- ("s390x", _) => false,
- // Unsupported <https://github.com/llvm/llvm-project/issues/94434>
- ("arm64ec", _) => false,
- // MinGW ABI bugs <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115054>
- ("x86_64", "windows") if target_env == "gnu" && target_abi != "llvm" => false,
- // Infinite recursion <https://github.com/llvm/llvm-project/issues/97981>
- ("csky", _) => false,
- ("hexagon", _) => false,
- ("powerpc" | "powerpc64", _) => false,
- ("sparc" | "sparc64", _) => false,
- ("wasm32" | "wasm64", _) => false,
- // `f16` support only requires that symbols converting to and from `f32` are available. We
- // provide these in `compiler-builtins`, so `f16` should be available on all platforms that
- // do not have other ABI issues or LLVM crashes.
- _ => true,
- };
-
- let has_reliable_f128 = match (target_arch.as_str(), target_os.as_str()) {
- // We can always enable these in Miri as that is not affected by codegen bugs.
- _ if is_miri => true,
- // Unsupported <https://github.com/llvm/llvm-project/issues/94434>
- ("arm64ec", _) => false,
- // Selection bug <https://github.com/llvm/llvm-project/issues/96432>
- ("mips64" | "mips64r6", _) => false,
- // Selection bug <https://github.com/llvm/llvm-project/issues/95471>
- ("nvptx64", _) => false,
- // ABI bugs <https://github.com/rust-lang/rust/issues/125109> et al. (full
- // list at <https://github.com/rust-lang/rust/issues/116909>)
- ("powerpc" | "powerpc64", _) => false,
- // ABI unsupported <https://github.com/llvm/llvm-project/issues/41838>
- ("sparc", _) => false,
- // Stack alignment bug <https://github.com/llvm/llvm-project/issues/77401>. NB: tests may
- // not fail if our compiler-builtins is linked.
- ("x86", _) => false,
- // MinGW ABI bugs <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115054>
- ("x86_64", "windows") if target_env == "gnu" && target_abi != "llvm" => false,
- // There are no known problems on other platforms, so the only requirement is that symbols
- // are available. `compiler-builtins` provides all symbols required for core `f128`
- // support, so this should work for everything else.
- _ => true,
- };
-
- // Configure platforms that have reliable basics but may have unreliable math.
-
- // LLVM is currently adding missing routines, <https://github.com/llvm/llvm-project/issues/93566>
- let has_reliable_f16_math = has_reliable_f16
- && match (target_arch.as_str(), target_os.as_str()) {
- // FIXME: Disabled on Miri as the intrinsics are not implemented yet.
- _ if is_miri => false,
- // x86 has a crash for `powi`: <https://github.com/llvm/llvm-project/issues/105747>
- ("x86" | "x86_64", _) => false,
- // Assume that working `f16` means working `f16` math for most platforms, since
- // operations just go through `f32`.
- _ => true,
- };
-
- let has_reliable_f128_math = has_reliable_f128
- && match (target_arch.as_str(), target_os.as_str()) {
- // FIXME: Disabled on Miri as the intrinsics are not implemented yet.
- _ if is_miri => false,
- // LLVM lowers `fp128` math to `long double` symbols even on platforms where
- // `long double` is not IEEE binary128. See
- // <https://github.com/llvm/llvm-project/issues/44744>.
- //
- // This rules out anything that doesn't have `long double` = `binary128`; <= 32 bits
- // (ld is `f64`), anything other than Linux (Windows and MacOS use `f64`), and `x86`
- // (ld is 80-bit extended precision).
- ("x86_64", _) => false,
- (_, "linux") if target_pointer_width == 64 => true,
- _ => false,
- };
-
- if has_reliable_f16 {
- println!("cargo:rustc-cfg=reliable_f16");
- }
- if has_reliable_f128 {
- println!("cargo:rustc-cfg=reliable_f128");
- }
- if has_reliable_f16_math {
- println!("cargo:rustc-cfg=reliable_f16_math");
- }
- if has_reliable_f128_math {
- println!("cargo:rustc-cfg=reliable_f128_math");
- }
}
diff --git a/library/std/src/f128.rs b/library/std/src/f128.rs
index 217528fdf1c10..2b416b13fa59c 100644
--- a/library/std/src/f128.rs
+++ b/library/std/src/f128.rs
@@ -22,7 +22,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let f = 3.7_f128;
/// let g = 3.0_f128;
@@ -49,7 +53,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let f = 3.01_f128;
/// let g = 4.0_f128;
@@ -76,7 +84,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let f = 3.3_f128;
/// let g = -3.3_f128;
@@ -108,7 +120,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let f = 3.3_f128;
/// let g = -3.3_f128;
@@ -138,7 +154,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let f = 3.7_f128;
/// let g = 3.0_f128;
@@ -166,7 +186,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let x = 3.6_f128;
/// let y = -3.6_f128;
@@ -203,7 +227,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let m = 10.0_f128;
/// let x = 4.0_f128;
@@ -247,7 +275,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let a: f128 = 7.0;
/// let b = 4.0;
@@ -289,7 +321,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let a: f128 = 7.0;
/// let b = 4.0;
@@ -326,7 +362,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let x = 2.0_f128;
/// let abs_difference = (x.powi(2) - (x * x)).abs();
@@ -354,7 +394,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let x = 2.0_f128;
/// let abs_difference = (x.powf(2.0) - (x * x)).abs();
@@ -386,7 +430,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let positive = 4.0_f128;
/// let negative = -4.0_f128;
@@ -417,7 +465,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let one = 1.0f128;
/// // e^1
@@ -448,7 +500,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let f = 2.0f128;
///
@@ -479,7 +535,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let one = 1.0f128;
/// // e^1
@@ -495,7 +555,11 @@ impl f128 {
/// Non-positive values:
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// assert_eq!(0_f128.ln(), f128::NEG_INFINITY);
/// assert!((-42_f128).ln().is_nan());
@@ -526,7 +590,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let five = 5.0f128;
///
@@ -540,7 +608,11 @@ impl f128 {
/// Non-positive values:
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// assert_eq!(0_f128.log(10.0), f128::NEG_INFINITY);
/// assert!((-42_f128).log(10.0).is_nan());
@@ -567,7 +639,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let two = 2.0f128;
///
@@ -581,7 +657,11 @@ impl f128 {
/// Non-positive values:
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// assert_eq!(0_f128.log2(), f128::NEG_INFINITY);
/// assert!((-42_f128).log2().is_nan());
@@ -608,7 +688,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let ten = 10.0f128;
///
@@ -622,7 +706,11 @@ impl f128 {
/// Non-positive values:
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// assert_eq!(0_f128.log10(), f128::NEG_INFINITY);
/// assert!((-42_f128).log10().is_nan());
@@ -651,7 +739,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let x = 8.0f128;
///
@@ -687,7 +779,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let x = 2.0f128;
/// let y = 3.0f128;
@@ -717,7 +813,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let x = std::f128::consts::FRAC_PI_2;
///
@@ -745,7 +845,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let x = 2.0 * std::f128::consts::PI;
///
@@ -776,7 +880,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let x = std::f128::consts::FRAC_PI_4;
/// let abs_difference = (x.tan() - 1.0).abs();
@@ -808,7 +916,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let f = std::f128::consts::FRAC_PI_2;
///
@@ -843,7 +955,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let f = std::f128::consts::FRAC_PI_4;
///
@@ -877,7 +993,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let f = 1.0f128;
///
@@ -915,7 +1035,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// // Positive angles measured counter-clockwise
/// // from positive x axis
@@ -957,7 +1081,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let x = std::f128::consts::FRAC_PI_4;
/// let f = x.sin_cos();
@@ -992,7 +1120,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let x = 1e-8_f128;
///
@@ -1028,7 +1160,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let x = 1e-8_f128;
///
@@ -1043,7 +1179,11 @@ impl f128 {
/// Out-of-range values:
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// assert_eq!((-1.0_f128).ln_1p(), f128::NEG_INFINITY);
/// assert!((-2.0_f128).ln_1p().is_nan());
@@ -1072,7 +1212,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let e = std::f128::consts::E;
/// let x = 1.0f128;
@@ -1107,7 +1251,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let e = std::f128::consts::E;
/// let x = 1.0f128;
@@ -1142,7 +1290,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let e = std::f128::consts::E;
/// let x = 1.0f128;
@@ -1174,7 +1326,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let x = 1.0f128;
/// let f = x.sinh().asinh();
@@ -1206,7 +1362,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let x = 1.0f128;
/// let f = x.cosh().acosh();
@@ -1240,7 +1400,11 @@ impl f128 {
///
/// ```
/// #![feature(f128)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let e = std::f128::consts::E;
/// let f = e.tanh().atanh();
@@ -1274,7 +1438,11 @@ impl f128 {
/// ```
/// #![feature(f128)]
/// #![feature(float_gamma)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let x = 5.0f128;
///
@@ -1309,7 +1477,11 @@ impl f128 {
/// ```
/// #![feature(f128)]
/// #![feature(float_gamma)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
///
/// let x = 2.0f128;
///
@@ -1344,7 +1516,11 @@ impl f128 {
/// ```
/// #![feature(f128)]
/// #![feature(float_erf)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
/// /// The error function relates what percent of a normal distribution lies
/// /// within `x` standard deviations (scaled by `1/sqrt(2)`).
/// fn within_standard_deviations(x: f128) -> f128 {
@@ -1383,7 +1559,11 @@ impl f128 {
/// ```
/// #![feature(f128)]
/// #![feature(float_erf)]
- /// # #[cfg(reliable_f128_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f128_math)] {
/// let x: f128 = 0.123;
///
/// let one = x.erf() + x.erfc();
diff --git a/library/std/src/f16.rs b/library/std/src/f16.rs
index 4dadcbb518556..3f88ab2d400e9 100644
--- a/library/std/src/f16.rs
+++ b/library/std/src/f16.rs
@@ -22,7 +22,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let f = 3.7_f16;
/// let g = 3.0_f16;
@@ -49,7 +53,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let f = 3.01_f16;
/// let g = 4.0_f16;
@@ -76,7 +84,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let f = 3.3_f16;
/// let g = -3.3_f16;
@@ -108,7 +120,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let f = 3.3_f16;
/// let g = -3.3_f16;
@@ -138,7 +154,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let f = 3.7_f16;
/// let g = 3.0_f16;
@@ -166,7 +186,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let x = 3.6_f16;
/// let y = -3.6_f16;
@@ -203,7 +227,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let m = 10.0_f16;
/// let x = 4.0_f16;
@@ -247,7 +275,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let a: f16 = 7.0;
/// let b = 4.0;
@@ -289,7 +321,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let a: f16 = 7.0;
/// let b = 4.0;
@@ -326,7 +362,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let x = 2.0_f16;
/// let abs_difference = (x.powi(2) - (x * x)).abs();
@@ -354,7 +394,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let x = 2.0_f16;
/// let abs_difference = (x.powf(2.0) - (x * x)).abs();
@@ -386,7 +430,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let positive = 4.0_f16;
/// let negative = -4.0_f16;
@@ -417,7 +465,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let one = 1.0f16;
/// // e^1
@@ -448,7 +500,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let f = 2.0f16;
///
@@ -479,7 +535,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let one = 1.0f16;
/// // e^1
@@ -495,7 +555,11 @@ impl f16 {
/// Non-positive values:
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// assert_eq!(0_f16.ln(), f16::NEG_INFINITY);
/// assert!((-42_f16).ln().is_nan());
@@ -526,7 +590,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let five = 5.0f16;
///
@@ -540,7 +608,11 @@ impl f16 {
/// Non-positive values:
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// assert_eq!(0_f16.log(10.0), f16::NEG_INFINITY);
/// assert!((-42_f16).log(10.0).is_nan());
@@ -567,7 +639,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let two = 2.0f16;
///
@@ -581,7 +657,11 @@ impl f16 {
/// Non-positive values:
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// assert_eq!(0_f16.log2(), f16::NEG_INFINITY);
/// assert!((-42_f16).log2().is_nan());
@@ -608,7 +688,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let ten = 10.0f16;
///
@@ -622,7 +706,11 @@ impl f16 {
/// Non-positive values:
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// assert_eq!(0_f16.log10(), f16::NEG_INFINITY);
/// assert!((-42_f16).log10().is_nan());
@@ -650,7 +738,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let x = 8.0f16;
///
@@ -685,7 +777,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let x = 2.0f16;
/// let y = 3.0f16;
@@ -715,7 +811,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let x = std::f16::consts::FRAC_PI_2;
///
@@ -743,7 +843,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let x = 2.0 * std::f16::consts::PI;
///
@@ -774,7 +878,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let x = std::f16::consts::FRAC_PI_4;
/// let abs_difference = (x.tan() - 1.0).abs();
@@ -806,7 +914,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let f = std::f16::consts::FRAC_PI_2;
///
@@ -841,7 +953,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let f = std::f16::consts::FRAC_PI_4;
///
@@ -875,7 +991,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let f = 1.0f16;
///
@@ -913,7 +1033,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// // Positive angles measured counter-clockwise
/// // from positive x axis
@@ -955,7 +1079,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let x = std::f16::consts::FRAC_PI_4;
/// let f = x.sin_cos();
@@ -990,7 +1118,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let x = 1e-4_f16;
///
@@ -1026,7 +1158,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let x = 1e-4_f16;
///
@@ -1041,7 +1177,11 @@ impl f16 {
/// Out-of-range values:
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// assert_eq!((-1.0_f16).ln_1p(), f16::NEG_INFINITY);
/// assert!((-2.0_f16).ln_1p().is_nan());
@@ -1070,7 +1210,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let e = std::f16::consts::E;
/// let x = 1.0f16;
@@ -1105,7 +1249,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let e = std::f16::consts::E;
/// let x = 1.0f16;
@@ -1140,7 +1288,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let e = std::f16::consts::E;
/// let x = 1.0f16;
@@ -1172,7 +1324,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let x = 1.0f16;
/// let f = x.sinh().asinh();
@@ -1204,7 +1360,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let x = 1.0f16;
/// let f = x.cosh().acosh();
@@ -1238,7 +1398,11 @@ impl f16 {
///
/// ```
/// #![feature(f16)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let e = std::f16::consts::E;
/// let f = e.tanh().atanh();
@@ -1272,7 +1436,11 @@ impl f16 {
/// ```
/// #![feature(f16)]
/// #![feature(float_gamma)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let x = 5.0f16;
///
@@ -1307,7 +1475,11 @@ impl f16 {
/// ```
/// #![feature(f16)]
/// #![feature(float_gamma)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
///
/// let x = 2.0f16;
///
@@ -1342,7 +1514,11 @@ impl f16 {
/// ```
/// #![feature(f16)]
/// #![feature(float_erf)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
/// /// The error function relates what percent of a normal distribution lies
/// /// within `x` standard deviations (scaled by `1/sqrt(2)`).
/// fn within_standard_deviations(x: f16) -> f16 {
@@ -1381,7 +1557,11 @@ impl f16 {
/// ```
/// #![feature(f16)]
/// #![feature(float_erf)]
- /// # #[cfg(reliable_f16_math)] {
+ /// # #![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+ /// # #![cfg_attr(not(bootstrap), expect(internal_features))]
+ /// # #[cfg(not(miri))]
+ /// # #[cfg(not(bootstrap))]
+ /// # #[cfg(target_has_reliable_f16_math)] {
/// let x: f16 = 0.123;
///
/// let one = x.erf() + x.erfc();
diff --git a/library/std/tests/floats/f128.rs b/library/std/tests/floats/f128.rs
index 677738bac8f98..8b13d6e65587a 100644
--- a/library/std/tests/floats/f128.rs
+++ b/library/std/tests/floats/f128.rs
@@ -1,9 +1,12 @@
// FIXME(f16_f128): only tested on platforms that have symbols and aren't buggy
-#![cfg(reliable_f128)]
+#![cfg(not(bootstrap))]
+#![cfg(target_has_reliable_f128)]
use std::f128::consts;
use std::num::FpCategory as Fp;
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
use std::ops::Rem;
use std::ops::{Add, Div, Mul, Sub};
@@ -19,7 +22,9 @@ const TOL: f128 = 1e-12;
/// Tolerances for math that is allowed to be imprecise, usually due to multiple chained
/// operations.
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
const TOL_IMPR: f128 = 1e-10;
/// Smallest number
@@ -66,8 +71,13 @@ fn test_num_f128() {
assert_eq!(ten.div(two), ten / two);
}
+// FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
+// the intrinsics.
+
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_num_f128_rem() {
let ten = 10f128;
let two = 2f128;
@@ -75,28 +85,36 @@ fn test_num_f128_rem() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_min_nan() {
assert_eq!(f128::NAN.min(2.0), 2.0);
assert_eq!(2.0f128.min(f128::NAN), 2.0);
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_max_nan() {
assert_eq!(f128::NAN.max(2.0), 2.0);
assert_eq!(2.0f128.max(f128::NAN), 2.0);
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_minimum() {
assert!(f128::NAN.minimum(2.0).is_nan());
assert!(2.0f128.minimum(f128::NAN).is_nan());
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_maximum() {
assert!(f128::NAN.maximum(2.0).is_nan());
assert!(2.0f128.maximum(f128::NAN).is_nan());
@@ -253,7 +271,9 @@ fn test_classify() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_floor() {
assert_approx_eq!(1.0f128.floor(), 1.0f128, TOL_PRECISE);
assert_approx_eq!(1.3f128.floor(), 1.0f128, TOL_PRECISE);
@@ -268,7 +288,9 @@ fn test_floor() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_ceil() {
assert_approx_eq!(1.0f128.ceil(), 1.0f128, TOL_PRECISE);
assert_approx_eq!(1.3f128.ceil(), 2.0f128, TOL_PRECISE);
@@ -283,7 +305,9 @@ fn test_ceil() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_round() {
assert_approx_eq!(2.5f128.round(), 3.0f128, TOL_PRECISE);
assert_approx_eq!(1.0f128.round(), 1.0f128, TOL_PRECISE);
@@ -299,7 +323,9 @@ fn test_round() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_round_ties_even() {
assert_approx_eq!(2.5f128.round_ties_even(), 2.0f128, TOL_PRECISE);
assert_approx_eq!(1.0f128.round_ties_even(), 1.0f128, TOL_PRECISE);
@@ -315,7 +341,9 @@ fn test_round_ties_even() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_trunc() {
assert_approx_eq!(1.0f128.trunc(), 1.0f128, TOL_PRECISE);
assert_approx_eq!(1.3f128.trunc(), 1.0f128, TOL_PRECISE);
@@ -330,7 +358,9 @@ fn test_trunc() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_fract() {
assert_approx_eq!(1.0f128.fract(), 0.0f128, TOL_PRECISE);
assert_approx_eq!(1.3f128.fract(), 0.3f128, TOL_PRECISE);
@@ -345,7 +375,9 @@ fn test_fract() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_abs() {
assert_eq!(f128::INFINITY.abs(), f128::INFINITY);
assert_eq!(1f128.abs(), 1f128);
@@ -445,7 +477,9 @@ fn test_next_down() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_mul_add() {
let nan: f128 = f128::NAN;
let inf: f128 = f128::INFINITY;
@@ -462,7 +496,9 @@ fn test_mul_add() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_recip() {
let nan: f128 = f128::NAN;
let inf: f128 = f128::INFINITY;
@@ -484,7 +520,9 @@ fn test_recip() {
// Many math functions allow for less accurate results, so the next tolerance up is used
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_powi() {
let nan: f128 = f128::NAN;
let inf: f128 = f128::INFINITY;
@@ -499,7 +537,9 @@ fn test_powi() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_powf() {
let nan: f128 = f128::NAN;
let inf: f128 = f128::INFINITY;
@@ -516,7 +556,9 @@ fn test_powf() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_sqrt_domain() {
assert!(f128::NAN.sqrt().is_nan());
assert!(f128::NEG_INFINITY.sqrt().is_nan());
@@ -528,7 +570,9 @@ fn test_sqrt_domain() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_exp() {
assert_eq!(1.0, 0.0f128.exp());
assert_approx_eq!(consts::E, 1.0f128.exp(), TOL);
@@ -543,7 +587,9 @@ fn test_exp() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_exp2() {
assert_eq!(32.0, 5.0f128.exp2());
assert_eq!(1.0, 0.0f128.exp2());
@@ -557,7 +603,9 @@ fn test_exp2() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_ln() {
let nan: f128 = f128::NAN;
let inf: f128 = f128::INFINITY;
@@ -573,7 +621,9 @@ fn test_ln() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_log() {
let nan: f128 = f128::NAN;
let inf: f128 = f128::INFINITY;
@@ -592,7 +642,9 @@ fn test_log() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_log2() {
let nan: f128 = f128::NAN;
let inf: f128 = f128::INFINITY;
@@ -609,7 +661,9 @@ fn test_log2() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_log10() {
let nan: f128 = f128::NAN;
let inf: f128 = f128::INFINITY;
@@ -659,7 +713,9 @@ fn test_to_radians() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_asinh() {
// Lower accuracy results are allowed, use increased tolerances
assert_eq!(0.0f128.asinh(), 0.0f128);
@@ -690,7 +746,9 @@ fn test_asinh() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_acosh() {
assert_eq!(1.0f128.acosh(), 0.0f128);
assert!(0.999f128.acosh().is_nan());
@@ -709,7 +767,9 @@ fn test_acosh() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_atanh() {
assert_eq!(0.0f128.atanh(), 0.0f128);
assert_eq!((-0.0f128).atanh(), -0.0f128);
@@ -729,7 +789,9 @@ fn test_atanh() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_gamma() {
// precision can differ among platforms
assert_approx_eq!(1.0f128.gamma(), 1.0f128, TOL_IMPR);
@@ -750,7 +812,9 @@ fn test_gamma() {
}
#[test]
-#[cfg(reliable_f128_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f128_math)]
fn test_ln_gamma() {
assert_approx_eq!(1.0f128.ln_gamma().0, 0.0f128, TOL_IMPR);
assert_eq!(1.0f128.ln_gamma().1, 1);
@@ -781,7 +845,9 @@ fn test_real_consts() {
assert_approx_eq!(frac_1_pi, 1f128 / pi, TOL_PRECISE);
assert_approx_eq!(frac_2_pi, 2f128 / pi, TOL_PRECISE);
- #[cfg(reliable_f128_math)]
+ #[cfg(not(miri))]
+ #[cfg(not(bootstrap))]
+ #[cfg(target_has_reliable_f128_math)]
{
let frac_2_sqrtpi: f128 = consts::FRAC_2_SQRT_PI;
let sqrt2: f128 = consts::SQRT_2;
diff --git a/library/std/tests/floats/f16.rs b/library/std/tests/floats/f16.rs
index 0fc4df8115a24..8b3b344dd467b 100644
--- a/library/std/tests/floats/f16.rs
+++ b/library/std/tests/floats/f16.rs
@@ -1,5 +1,6 @@
// FIXME(f16_f128): only tested on platforms that have symbols and aren't buggy
-#![cfg(reliable_f16)]
+#![cfg(not(bootstrap))]
+#![cfg(target_has_reliable_f16)]
use std::f16::consts;
use std::num::FpCategory as Fp;
@@ -57,29 +58,40 @@ fn test_num_f16() {
crate::test_num(10f16, 2f16);
}
+// FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
+// the intrinsics.
+
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_min_nan() {
assert_eq!(f16::NAN.min(2.0), 2.0);
assert_eq!(2.0f16.min(f16::NAN), 2.0);
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_max_nan() {
assert_eq!(f16::NAN.max(2.0), 2.0);
assert_eq!(2.0f16.max(f16::NAN), 2.0);
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_minimum() {
assert!(f16::NAN.minimum(2.0).is_nan());
assert!(2.0f16.minimum(f16::NAN).is_nan());
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_maximum() {
assert!(f16::NAN.maximum(2.0).is_nan());
assert!(2.0f16.maximum(f16::NAN).is_nan());
@@ -236,7 +248,9 @@ fn test_classify() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_floor() {
assert_approx_eq!(1.0f16.floor(), 1.0f16, TOL_0);
assert_approx_eq!(1.3f16.floor(), 1.0f16, TOL_0);
@@ -251,7 +265,9 @@ fn test_floor() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_ceil() {
assert_approx_eq!(1.0f16.ceil(), 1.0f16, TOL_0);
assert_approx_eq!(1.3f16.ceil(), 2.0f16, TOL_0);
@@ -266,7 +282,9 @@ fn test_ceil() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_round() {
assert_approx_eq!(2.5f16.round(), 3.0f16, TOL_0);
assert_approx_eq!(1.0f16.round(), 1.0f16, TOL_0);
@@ -282,7 +300,9 @@ fn test_round() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_round_ties_even() {
assert_approx_eq!(2.5f16.round_ties_even(), 2.0f16, TOL_0);
assert_approx_eq!(1.0f16.round_ties_even(), 1.0f16, TOL_0);
@@ -298,7 +318,9 @@ fn test_round_ties_even() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_trunc() {
assert_approx_eq!(1.0f16.trunc(), 1.0f16, TOL_0);
assert_approx_eq!(1.3f16.trunc(), 1.0f16, TOL_0);
@@ -313,7 +335,9 @@ fn test_trunc() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_fract() {
assert_approx_eq!(1.0f16.fract(), 0.0f16, TOL_0);
assert_approx_eq!(1.3f16.fract(), 0.3f16, TOL_0);
@@ -328,7 +352,9 @@ fn test_fract() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_abs() {
assert_eq!(f16::INFINITY.abs(), f16::INFINITY);
assert_eq!(1f16.abs(), 1f16);
@@ -428,7 +454,9 @@ fn test_next_down() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_mul_add() {
let nan: f16 = f16::NAN;
let inf: f16 = f16::INFINITY;
@@ -445,7 +473,9 @@ fn test_mul_add() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_recip() {
let nan: f16 = f16::NAN;
let inf: f16 = f16::INFINITY;
@@ -461,7 +491,9 @@ fn test_recip() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_powi() {
let nan: f16 = f16::NAN;
let inf: f16 = f16::INFINITY;
@@ -476,7 +508,9 @@ fn test_powi() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_powf() {
let nan: f16 = f16::NAN;
let inf: f16 = f16::INFINITY;
@@ -493,7 +527,9 @@ fn test_powf() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_sqrt_domain() {
assert!(f16::NAN.sqrt().is_nan());
assert!(f16::NEG_INFINITY.sqrt().is_nan());
@@ -505,7 +541,9 @@ fn test_sqrt_domain() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_exp() {
assert_eq!(1.0, 0.0f16.exp());
assert_approx_eq!(2.718282, 1.0f16.exp(), TOL_0);
@@ -520,7 +558,9 @@ fn test_exp() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_exp2() {
assert_eq!(32.0, 5.0f16.exp2());
assert_eq!(1.0, 0.0f16.exp2());
@@ -534,7 +574,9 @@ fn test_exp2() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_ln() {
let nan: f16 = f16::NAN;
let inf: f16 = f16::INFINITY;
@@ -550,7 +592,9 @@ fn test_ln() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_log() {
let nan: f16 = f16::NAN;
let inf: f16 = f16::INFINITY;
@@ -569,7 +613,9 @@ fn test_log() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_log2() {
let nan: f16 = f16::NAN;
let inf: f16 = f16::INFINITY;
@@ -586,7 +632,9 @@ fn test_log2() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_log10() {
let nan: f16 = f16::NAN;
let inf: f16 = f16::INFINITY;
@@ -634,7 +682,9 @@ fn test_to_radians() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_asinh() {
assert_eq!(0.0f16.asinh(), 0.0f16);
assert_eq!((-0.0f16).asinh(), -0.0f16);
@@ -659,7 +709,9 @@ fn test_asinh() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_acosh() {
assert_eq!(1.0f16.acosh(), 0.0f16);
assert!(0.999f16.acosh().is_nan());
@@ -678,7 +730,9 @@ fn test_acosh() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_atanh() {
assert_eq!(0.0f16.atanh(), 0.0f16);
assert_eq!((-0.0f16).atanh(), -0.0f16);
@@ -698,7 +752,9 @@ fn test_atanh() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_gamma() {
// precision can differ among platforms
assert_approx_eq!(1.0f16.gamma(), 1.0f16, TOL_0);
@@ -719,7 +775,9 @@ fn test_gamma() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_ln_gamma() {
assert_approx_eq!(1.0f16.ln_gamma().0, 0.0f16, TOL_0);
assert_eq!(1.0f16.ln_gamma().1, 1);
@@ -752,7 +810,9 @@ fn test_real_consts() {
assert_approx_eq!(frac_1_pi, 1f16 / pi, TOL_0);
assert_approx_eq!(frac_2_pi, 2f16 / pi, TOL_0);
- #[cfg(reliable_f16_math)]
+ #[cfg(not(miri))]
+ #[cfg(not(bootstrap))]
+ #[cfg(target_has_reliable_f16_math)]
{
let frac_2_sqrtpi: f16 = consts::FRAC_2_SQRT_PI;
let sqrt2: f16 = consts::SQRT_2;
@@ -813,7 +873,9 @@ fn test_clamp_max_is_nan() {
}
#[test]
-#[cfg(reliable_f16_math)]
+#[cfg(not(miri))]
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16_math)]
fn test_total_cmp() {
use core::cmp::Ordering;
diff --git a/library/std/tests/floats/lib.rs b/library/std/tests/floats/lib.rs
index de5a3cdbd0f93..7884fc9239e20 100644
--- a/library/std/tests/floats/lib.rs
+++ b/library/std/tests/floats/lib.rs
@@ -1,4 +1,6 @@
#![feature(f16, f128, float_algebraic, float_gamma, float_minimum_maximum)]
+#![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
+#![cfg_attr(not(bootstrap), expect(internal_features))] // for reliable_f16_f128
use std::fmt;
use std::ops::{Add, Div, Mul, Rem, Sub};
diff --git a/src/bootstrap/src/utils/tests/git.rs b/src/bootstrap/src/utils/tests/git.rs
index bd40f398c7b10..d9dd9ab980088 100644
--- a/src/bootstrap/src/utils/tests/git.rs
+++ b/src/bootstrap/src/utils/tests/git.rs
@@ -129,6 +129,9 @@ impl GitCtx {
fn git_cmd(&self) -> Command {
let mut cmd = Command::new("git");
+ cmd.env("GIT_CONFIG_NOSYSTEM", "1");
+ cmd.env("GIT_CONFIG_SYSTEM", "/tmp/nonexistent");
+ cmd.env("GIT_CONFIG_GLOBAL", "/tmp/nonexistent");
cmd.current_dir(&self.dir);
cmd
}
diff --git a/src/doc/unstable-book/src/language-features/deref-patterns.md b/src/doc/unstable-book/src/language-features/deref-patterns.md
index d0a64538e8ccc..0cc7106da48f4 100644
--- a/src/doc/unstable-book/src/language-features/deref-patterns.md
+++ b/src/doc/unstable-book/src/language-features/deref-patterns.md
@@ -7,7 +7,7 @@ The tracking issue for this feature is: [#87121]
------------------------
> **Note**: This feature is incomplete. In the future, it is meant to supersede
-> [`box_patterns`](./box-patterns.md) and [`string_deref_patterns`](./string-deref-patterns.md).
+> [`box_patterns`] and [`string_deref_patterns`].
This feature permits pattern matching on [smart pointers in the standard library] through their
`Deref` target types, either implicitly or with explicit `deref!(_)` patterns (the syntax of which
@@ -54,6 +54,17 @@ if let [b] = &mut *v {
assert_eq!(v, [Box::new(Some(2))]);
```
+Like [`box_patterns`], deref patterns may move out of boxes:
+
+```rust
+# #![feature(deref_patterns)]
+# #![allow(incomplete_features)]
+struct NoCopy;
+// Match exhaustiveness analysis is not yet implemented.
+let deref!(x) = Box::new(NoCopy) else { unreachable!() };
+drop::<NoCopy>(x);
+```
+
Additionally, when `deref_patterns` is enabled, string literal patterns may be written where `str`
is expected. Likewise, byte string literal patterns may be written where `[u8]` or `[u8; _]` is
expected. This lets them be used in `deref!(_)` patterns:
@@ -75,4 +86,6 @@ match *"test" {
Implicit deref pattern syntax is not yet supported for string or byte string literals.
+[`box_patterns`]: ./box-patterns.md
+[`string_deref_patterns`]: ./string-deref-patterns.md
[smart pointers in the standard library]: https://doc.rust-lang.org/std/ops/trait.DerefPure.html#implementors
diff --git a/src/tools/miri/tests/pass/slices.rs b/src/tools/miri/tests/pass/slices.rs
index dd18a061cdd51..686683c3a25cf 100644
--- a/src/tools/miri/tests/pass/slices.rs
+++ b/src/tools/miri/tests/pass/slices.rs
@@ -1,7 +1,6 @@
//@revisions: stack tree
//@[tree]compile-flags: -Zmiri-tree-borrows
//@compile-flags: -Zmiri-strict-provenance
-#![feature(slice_as_chunks)]
#![feature(slice_partition_dedup)]
#![feature(layout_for_ptr)]
@@ -227,7 +226,7 @@ fn test_for_invalidated_pointers() {
buffer.reverse();
- // Calls `fn as_chunks_unchecked_mut` internally (requires unstable `#![feature(slice_as_chunks)]`):
+ // Calls `fn as_chunks_unchecked_mut` internally:
assert_eq!(2, buffer.as_chunks_mut::<32>().0.len());
for chunk in buffer.as_chunks_mut::<32>().0 {
for elem in chunk {
diff --git a/tests/codegen/autodiff/inline.rs b/tests/codegen/autodiff/inline.rs
new file mode 100644
index 0000000000000..e90faa4aa3802
--- /dev/null
+++ b/tests/codegen/autodiff/inline.rs
@@ -0,0 +1,23 @@
+//@ compile-flags: -Zautodiff=Enable -C opt-level=3 -Clto=fat -Zautodiff=NoPostopt
+//@ no-prefer-dynamic
+//@ needs-enzyme
+
+#![feature(autodiff)]
+
+use std::autodiff::autodiff;
+
+#[autodiff(d_square, Reverse, Duplicated, Active)]
+fn square(x: &f64) -> f64 {
+ x * x
+}
+
+// CHECK: ; inline::d_square
+// CHECK-NEXT: ; Function Attrs: alwaysinline
+// CHECK-NOT: noinline
+// CHECK-NEXT: define internal fastcc void @_ZN6inline8d_square17h021c74e92c259cdeE
+fn main() {
+ let x = std::hint::black_box(3.0);
+ let mut dx1 = std::hint::black_box(1.0);
+ let _ = d_square(&x, &mut dx1, 1.0);
+ assert_eq!(dx1, 6.0);
+}
diff --git a/tests/codegen/slice-as_chunks.rs b/tests/codegen/slice-as_chunks.rs
index a90ee7c628ece..337eb8981f6dd 100644
--- a/tests/codegen/slice-as_chunks.rs
+++ b/tests/codegen/slice-as_chunks.rs
@@ -2,7 +2,6 @@
//@ only-64bit (because the LLVM type of i64 for usize shows up)
#![crate_type = "lib"]
-#![feature(slice_as_chunks)]
// CHECK-LABEL: @chunks4
#[no_mangle]
diff --git a/tests/run-make/amdgpu-kd/rmake.rs b/tests/run-make/amdgpu-kd/rmake.rs
index a787fa1da93aa..cba9030641dec 100644
--- a/tests/run-make/amdgpu-kd/rmake.rs
+++ b/tests/run-make/amdgpu-kd/rmake.rs
@@ -6,13 +6,19 @@
//@ needs-llvm-components: amdgpu
//@ needs-rust-lld
+use run_make_support::targets::is_windows_gnu;
use run_make_support::{llvm_readobj, rustc};
fn main() {
+ // FIXME(#115985): rust-lld on gnu targets may spuriously fail with
+ // STATUS_HEAP_CORRUPTION (0xc0000374).
+ // To try to mitigate this we pass --threads=1 to the linker.
+ let extra_args: &[&str] = if is_windows_gnu() { &["-C", "link-arg=--threads=1"] } else { &[] };
rustc()
.crate_name("foo")
.target("amdgcn-amd-amdhsa")
.arg("-Ctarget-cpu=gfx900")
+ .args(&extra_args)
.crate_type("cdylib")
.input("foo.rs")
.run();
diff --git a/tests/ui/asm/named_const_simd_vec_len.rs b/tests/ui/asm/named_const_simd_vec_len.rs
index 7df4d922d5c91..7fedeb7d4d122 100644
--- a/tests/ui/asm/named_const_simd_vec_len.rs
+++ b/tests/ui/asm/named_const_simd_vec_len.rs
@@ -3,6 +3,9 @@
//@ only-x86_64
//@ check-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
#![feature(repr_simd)]
diff --git a/tests/ui/asm/normalizable-asm-ty.rs b/tests/ui/asm/normalizable-asm-ty.rs
new file mode 100644
index 0000000000000..c1f3f3ecd6168
--- /dev/null
+++ b/tests/ui/asm/normalizable-asm-ty.rs
@@ -0,0 +1,16 @@
+//@ check-pass
+//@ needs-asm-support
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+
+fn invoke(pc_section: &[usize]) {
+ unsafe {
+ std::arch::asm!(
+ "/* {} */",
+ in(reg) pc_section[0]
+ );
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/in-trait/cycle-if-impl-doesnt-apply.rs b/tests/ui/async-await/in-trait/cycle-if-impl-doesnt-apply.rs
new file mode 100644
index 0000000000000..54992c986558c
--- /dev/null
+++ b/tests/ui/async-await/in-trait/cycle-if-impl-doesnt-apply.rs
@@ -0,0 +1,39 @@
+//@ check-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+//@ edition: 2024
+
+// Regression test for <https://github.com/rust-lang/trait-system-refactor-initiative/issues/185>.
+// Avoid unnecessarily computing the RPITIT type of the first impl when checking the WF of the
+// second impl, since the first impl relies on the hidden type of the second impl.
+
+use std::future::Future;
+
+trait Handler {}
+
+struct W<T>(T);
+
+trait SendTarget {
+ fn call(self) -> impl Future<Output = ()> + Send;
+}
+
+impl<T> SendTarget for W<T>
+where
+ T: Handler + Send,
+{
+ async fn call(self) {
+ todo!()
+ }
+}
+
+impl<T> SendTarget for T
+where
+ T: Handler + Send,
+{
+ async fn call(self) {
+ W(self).call().await
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/cfg/disallowed-cli-cfgs.reliable_f128_.stderr b/tests/ui/cfg/disallowed-cli-cfgs.reliable_f128_.stderr
new file mode 100644
index 0000000000000..1b6e05060017e
--- /dev/null
+++ b/tests/ui/cfg/disallowed-cli-cfgs.reliable_f128_.stderr
@@ -0,0 +1,8 @@
+error: unexpected `--cfg target_has_reliable_f128` flag
+ |
+ = note: config `target_has_reliable_f128` is only supposed to be controlled by `--target`
+ = note: manually setting a built-in cfg can and does create incoherent behaviors
+ = note: `#[deny(explicit_builtin_cfgs_in_flags)]` on by default
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/cfg/disallowed-cli-cfgs.reliable_f128_math_.stderr b/tests/ui/cfg/disallowed-cli-cfgs.reliable_f128_math_.stderr
new file mode 100644
index 0000000000000..86e7342b8fc1e
--- /dev/null
+++ b/tests/ui/cfg/disallowed-cli-cfgs.reliable_f128_math_.stderr
@@ -0,0 +1,8 @@
+error: unexpected `--cfg target_has_reliable_f128_math` flag
+ |
+ = note: config `target_has_reliable_f128_math` is only supposed to be controlled by `--target`
+ = note: manually setting a built-in cfg can and does create incoherent behaviors
+ = note: `#[deny(explicit_builtin_cfgs_in_flags)]` on by default
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/cfg/disallowed-cli-cfgs.reliable_f16_.stderr b/tests/ui/cfg/disallowed-cli-cfgs.reliable_f16_.stderr
new file mode 100644
index 0000000000000..cf5000ecf2741
--- /dev/null
+++ b/tests/ui/cfg/disallowed-cli-cfgs.reliable_f16_.stderr
@@ -0,0 +1,8 @@
+error: unexpected `--cfg target_has_reliable_f16` flag
+ |
+ = note: config `target_has_reliable_f16` is only supposed to be controlled by `--target`
+ = note: manually setting a built-in cfg can and does create incoherent behaviors
+ = note: `#[deny(explicit_builtin_cfgs_in_flags)]` on by default
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/cfg/disallowed-cli-cfgs.reliable_f16_math_.stderr b/tests/ui/cfg/disallowed-cli-cfgs.reliable_f16_math_.stderr
new file mode 100644
index 0000000000000..079e5627e4c2b
--- /dev/null
+++ b/tests/ui/cfg/disallowed-cli-cfgs.reliable_f16_math_.stderr
@@ -0,0 +1,8 @@
+error: unexpected `--cfg target_has_reliable_f16_math` flag
+ |
+ = note: config `target_has_reliable_f16_math` is only supposed to be controlled by `--target`
+ = note: manually setting a built-in cfg can and does create incoherent behaviors
+ = note: `#[deny(explicit_builtin_cfgs_in_flags)]` on by default
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/cfg/disallowed-cli-cfgs.rs b/tests/ui/cfg/disallowed-cli-cfgs.rs
index e9661abf3abea..f7f9d2b5cd7f9 100644
--- a/tests/ui/cfg/disallowed-cli-cfgs.rs
+++ b/tests/ui/cfg/disallowed-cli-cfgs.rs
@@ -8,6 +8,7 @@
//@ revisions: target_thread_local_ relocation_model_
//@ revisions: fmt_debug_
//@ revisions: emscripten_wasm_eh_
+//@ revisions: reliable_f16_ reliable_f16_math_ reliable_f128_ reliable_f128_math_
//@ [overflow_checks_]compile-flags: --cfg overflow_checks
//@ [debug_assertions_]compile-flags: --cfg debug_assertions
@@ -35,6 +36,10 @@
//@ [relocation_model_]compile-flags: --cfg relocation_model="a"
//@ [fmt_debug_]compile-flags: --cfg fmt_debug="shallow"
//@ [emscripten_wasm_eh_]compile-flags: --cfg emscripten_wasm_eh
+//@ [reliable_f16_]compile-flags: --cfg target_has_reliable_f16
+//@ [reliable_f16_math_]compile-flags: --cfg target_has_reliable_f16_math
+//@ [reliable_f128_]compile-flags: --cfg target_has_reliable_f128
+//@ [reliable_f128_math_]compile-flags: --cfg target_has_reliable_f128_math
fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-cfg-target-has-reliable-f16-f128.rs b/tests/ui/feature-gates/feature-gate-cfg-target-has-reliable-f16-f128.rs
new file mode 100644
index 0000000000000..f1b0e3b01a423
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-cfg-target-has-reliable-f16-f128.rs
@@ -0,0 +1,12 @@
+//@ compile-flags: --check-cfg=cfg(target_has_reliable_f16,target_has_reliable_f16_math,target_has_reliable_f128,target_has_reliable_f128_math)
+
+fn main() {
+ cfg!(target_has_reliable_f16);
+ //~^ ERROR `cfg(target_has_reliable_f16)` is experimental and subject to change
+ cfg!(target_has_reliable_f16_math);
+ //~^ ERROR `cfg(target_has_reliable_f16_math)` is experimental and subject to change
+ cfg!(target_has_reliable_f128);
+ //~^ ERROR `cfg(target_has_reliable_f128)` is experimental and subject to change
+ cfg!(target_has_reliable_f128_math);
+ //~^ ERROR `cfg(target_has_reliable_f128_math)` is experimental and subject to change
+}
diff --git a/tests/ui/feature-gates/feature-gate-cfg-target-has-reliable-f16-f128.stderr b/tests/ui/feature-gates/feature-gate-cfg-target-has-reliable-f16-f128.stderr
new file mode 100644
index 0000000000000..9b90d18699e6f
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-cfg-target-has-reliable-f16-f128.stderr
@@ -0,0 +1,39 @@
+error[E0658]: `cfg(target_has_reliable_f16)` is experimental and subject to change
+ --> $DIR/feature-gate-cfg-target-has-reliable-f16-f128.rs:4:10
+ |
+LL | cfg!(target_has_reliable_f16);
+ | ^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add `#![feature(cfg_target_has_reliable_f16_f128)]` 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]: `cfg(target_has_reliable_f16_math)` is experimental and subject to change
+ --> $DIR/feature-gate-cfg-target-has-reliable-f16-f128.rs:6:10
+ |
+LL | cfg!(target_has_reliable_f16_math);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add `#![feature(cfg_target_has_reliable_f16_f128)]` 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]: `cfg(target_has_reliable_f128)` is experimental and subject to change
+ --> $DIR/feature-gate-cfg-target-has-reliable-f16-f128.rs:8:10
+ |
+LL | cfg!(target_has_reliable_f128);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add `#![feature(cfg_target_has_reliable_f16_f128)]` 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]: `cfg(target_has_reliable_f128_math)` is experimental and subject to change
+ --> $DIR/feature-gate-cfg-target-has-reliable-f16-f128.rs:10:10
+ |
+LL | cfg!(target_has_reliable_f128_math);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add `#![feature(cfg_target_has_reliable_f16_f128)]` 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 4 previous errors
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/float/target-has-reliable-nightly-float.rs b/tests/ui/float/target-has-reliable-nightly-float.rs
new file mode 100644
index 0000000000000..ad8600fc63593
--- /dev/null
+++ b/tests/ui/float/target-has-reliable-nightly-float.rs
@@ -0,0 +1,31 @@
+//@ run-pass
+//@ compile-flags: --check-cfg=cfg(target_has_reliable_f16,target_has_reliable_f16_math,target_has_reliable_f128,target_has_reliable_f128_math)
+// Verify that the feature gates and config work and are registered as known config
+// options.
+
+#![deny(unexpected_cfgs)]
+#![feature(cfg_target_has_reliable_f16_f128)]
+
+#[cfg(target_has_reliable_f16)]
+pub fn has_f16() {}
+
+#[cfg(target_has_reliable_f16_math)]
+pub fn has_f16_math() {}
+
+#[cfg(target_has_reliable_f128 )]
+pub fn has_f128() {}
+
+#[cfg(target_has_reliable_f128_math)]
+pub fn has_f128_math() {}
+
+fn main() {
+ if cfg!(target_arch = "aarch64") && cfg!(target_os = "linux") {
+ // Aarch64+Linux is one target that has support for all features, so use it to spot
+ // check that the compiler does indeed enable these gates.
+
+ assert!(cfg!(target_has_reliable_f16));
+ assert!(cfg!(target_has_reliable_f16_math));
+ assert!(cfg!(target_has_reliable_f128));
+ assert!(cfg!(target_has_reliable_f128_math));
+ }
+}
diff --git a/tests/ui/impl-trait/in-trait/cycle-if-impl-doesnt-apply.rs b/tests/ui/impl-trait/in-trait/cycle-if-impl-doesnt-apply.rs
new file mode 100644
index 0000000000000..72e08ed350426
--- /dev/null
+++ b/tests/ui/impl-trait/in-trait/cycle-if-impl-doesnt-apply.rs
@@ -0,0 +1,32 @@
+//@ check-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+//@ edition: 2024
+
+// Regression test for <https://github.com/rust-lang/trait-system-refactor-initiative/issues/185>.
+// Avoid unnecessarily computing the RPITIT type of the first impl when checking the WF of the
+// second impl, since the first impl relies on the hidden type of the second impl.
+
+trait Foo {
+ fn call(self) -> impl Send;
+}
+
+trait Nested {}
+impl<T> Foo for T
+where
+ T: Nested,
+{
+ fn call(self) -> impl Sized {
+ NotSatisfied.call()
+ }
+}
+
+struct NotSatisfied;
+impl Foo for NotSatisfied {
+ fn call(self) -> impl Sized {
+ todo!()
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/pattern/deref-patterns/bindings.rs b/tests/ui/pattern/deref-patterns/bindings.rs
index c14d57f3f24e6..ac48e3ffefccd 100644
--- a/tests/ui/pattern/deref-patterns/bindings.rs
+++ b/tests/ui/pattern/deref-patterns/bindings.rs
@@ -3,6 +3,8 @@
#![feature(deref_patterns)]
#![allow(incomplete_features)]
+use std::rc::Rc;
+
#[cfg(explicit)]
fn simple_vec(vec: Vec<u32>) -> u32 {
match vec {
@@ -53,29 +55,29 @@ fn nested_vec(vecvec: Vec<Vec<u32>>) -> u32 {
#[cfg(explicit)]
fn ref_mut(val: u32) -> u32 {
- let mut b = Box::new(0u32);
+ let mut b = vec![0u32];
match &mut b {
- deref!(_x) if false => unreachable!(),
- deref!(x) => {
+ deref!([_x]) if false => unreachable!(),
+ deref!([x]) => {
*x = val;
}
_ => unreachable!(),
}
- let deref!(x) = &b else { unreachable!() };
+ let deref!([x]) = &b else { unreachable!() };
*x
}
#[cfg(implicit)]
fn ref_mut(val: u32) -> u32 {
- let mut b = Box::new((0u32,));
+ let mut b = vec![0u32];
match &mut b {
- (_x,) if false => unreachable!(),
- (x,) => {
+ [_x] if false => unreachable!(),
+ [x] => {
*x = val;
}
_ => unreachable!(),
}
- let (x,) = &b else { unreachable!() };
+ let [x] = &b else { unreachable!() };
*x
}
@@ -83,7 +85,7 @@ fn ref_mut(val: u32) -> u32 {
#[rustfmt::skip]
fn or_and_guard(tuple: (u32, u32)) -> u32 {
let mut sum = 0;
- let b = Box::new(tuple);
+ let b = Rc::new(tuple);
match b {
deref!((x, _) | (_, x)) if { sum += x; false } => {},
_ => {},
@@ -95,7 +97,7 @@ fn or_and_guard(tuple: (u32, u32)) -> u32 {
#[rustfmt::skip]
fn or_and_guard(tuple: (u32, u32)) -> u32 {
let mut sum = 0;
- let b = Box::new(tuple);
+ let b = Rc::new(tuple);
match b {
(x, _) | (_, x) if { sum += x; false } => {},
_ => {},
diff --git a/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.rs b/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.rs
index 791776be5acad..2b4746e33e678 100644
--- a/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.rs
+++ b/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.rs
@@ -5,11 +5,11 @@ use std::rc::Rc;
struct Struct;
-fn cant_move_out_box(b: Box<Struct>) -> Struct {
+fn cant_move_out_vec(b: Vec<Struct>) -> Struct {
match b {
- //~^ ERROR: cannot move out of a shared reference
- deref!(x) => x,
- _ => unreachable!(),
+ //~^ ERROR: cannot move out of type `[Struct]`, a non-copy slice
+ deref!([x]) => x,
+ _ => panic!(),
}
}
@@ -21,16 +21,16 @@ fn cant_move_out_rc(rc: Rc<Struct>) -> Struct {
}
}
-struct Container(Struct);
-
-fn cant_move_out_box_implicit(b: Box<Container>) -> Struct {
+fn cant_move_out_vec_implicit(b: Vec<Struct>) -> Struct {
match b {
- //~^ ERROR: cannot move out of a shared reference
- Container(x) => x,
- _ => unreachable!(),
+ //~^ ERROR: cannot move out of type `[Struct]`, a non-copy slice
+ [x] => x,
+ _ => panic!(),
}
}
+struct Container(Struct);
+
fn cant_move_out_rc_implicit(rc: Rc<Container>) -> Struct {
match rc {
//~^ ERROR: cannot move out of a shared reference
diff --git a/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.stderr b/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.stderr
index 1887800fc38a8..a548ac5909a8c 100644
--- a/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.stderr
+++ b/tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.stderr
@@ -1,19 +1,19 @@
-error[E0507]: cannot move out of a shared reference
+error[E0508]: cannot move out of type `[Struct]`, a non-copy slice
--> $DIR/cant_move_out_of_pattern.rs:9:11
|
LL | match b {
- | ^
+ | ^ cannot move out of here
LL |
-LL | deref!(x) => x,
- | -
- | |
- | data moved here
- | move occurs because `x` has type `Struct`, which does not implement the `Copy` trait
+LL | deref!([x]) => x,
+ | -
+ | |
+ | data moved here
+ | move occurs because `x` has type `Struct`, which does not implement the `Copy` trait
|
help: consider borrowing the pattern binding
|
-LL | deref!(ref x) => x,
- | +++
+LL | deref!([ref x]) => x,
+ | +++
error[E0507]: cannot move out of a shared reference
--> $DIR/cant_move_out_of_pattern.rs:17:11
@@ -32,22 +32,22 @@ help: consider borrowing the pattern binding
LL | deref!(ref x) => x,
| +++
-error[E0507]: cannot move out of a shared reference
- --> $DIR/cant_move_out_of_pattern.rs:27:11
+error[E0508]: cannot move out of type `[Struct]`, a non-copy slice
+ --> $DIR/cant_move_out_of_pattern.rs:25:11
|
LL | match b {
- | ^
+ | ^ cannot move out of here
LL |
-LL | Container(x) => x,
- | -
- | |
- | data moved here
- | move occurs because `x` has type `Struct`, which does not implement the `Copy` trait
+LL | [x] => x,
+ | -
+ | |
+ | data moved here
+ | move occurs because `x` has type `Struct`, which does not implement the `Copy` trait
|
help: consider borrowing the pattern binding
|
-LL | Container(ref x) => x,
- | +++
+LL | [ref x] => x,
+ | +++
error[E0507]: cannot move out of a shared reference
--> $DIR/cant_move_out_of_pattern.rs:35:11
@@ -68,4 +68,5 @@ LL | Container(ref x) => x,
error: aborting due to 4 previous errors
-For more information about this error, try `rustc --explain E0507`.
+Some errors have detailed explanations: E0507, E0508.
+For more information about an error, try `rustc --explain E0507`.
diff --git a/tests/ui/pattern/deref-patterns/closure_capture.rs b/tests/ui/pattern/deref-patterns/closure_capture.rs
index 08586b6c7abdf..cf78eeda1d5aa 100644
--- a/tests/ui/pattern/deref-patterns/closure_capture.rs
+++ b/tests/ui/pattern/deref-patterns/closure_capture.rs
@@ -2,8 +2,12 @@
#![feature(deref_patterns)]
#![allow(incomplete_features)]
+use std::rc::Rc;
+
+struct NoCopy;
+
fn main() {
- let b = Box::new("aaa".to_string());
+ let b = Rc::new("aaa".to_string());
let f = || {
let deref!(ref s) = b else { unreachable!() };
assert_eq!(s.len(), 3);
@@ -20,13 +24,13 @@ fn main() {
assert_eq!(v, [1, 2, 3]);
f();
- let mut b = Box::new("aaa".to_string());
+ let mut b = "aaa".to_string();
let mut f = || {
let deref!(ref mut s) = b else { unreachable!() };
- s.push_str("aa");
+ s.make_ascii_uppercase();
};
f();
- assert_eq!(b.len(), 5);
+ assert_eq!(b, "AAA");
let mut v = vec![1, 2, 3];
let mut f = || {
@@ -45,4 +49,20 @@ fn main() {
};
f();
assert_eq!(v, [1, 2, 4]);
+
+ let b = Box::new(NoCopy);
+ let f = || {
+ // this should move out of the box rather than borrow.
+ let deref!(x) = b else { unreachable!() };
+ drop::<NoCopy>(x);
+ };
+ f();
+
+ let b = Box::new((NoCopy,));
+ let f = || {
+ // this should move out of the box rather than borrow.
+ let (x,) = b else { unreachable!() };
+ drop::<NoCopy>(x);
+ };
+ f();
}
diff --git a/tests/ui/pattern/deref-patterns/deref-box.rs b/tests/ui/pattern/deref-patterns/deref-box.rs
new file mode 100644
index 0000000000000..2d0a8d01972eb
--- /dev/null
+++ b/tests/ui/pattern/deref-patterns/deref-box.rs
@@ -0,0 +1,37 @@
+//@ run-pass
+//! Deref patterns on boxes are lowered using built-in derefs, rather than generic `Deref::deref`
+//! and `DerefMut::deref_mut`. Test that they work as expected.
+
+#![feature(deref_patterns)]
+#![expect(incomplete_features)]
+
+fn unbox_1<T>(b: Box<T>) -> T {
+ let deref!(x) = b else { unreachable!() };
+ x
+}
+
+fn unbox_2<T>(b: Box<(T,)>) -> T {
+ let (x,) = b else { unreachable!() };
+ x
+}
+
+fn unbox_separately<T>(b: Box<(T, T)>) -> (T, T) {
+ let (x, _) = b else { unreachable!() };
+ let (_, y) = b else { unreachable!() };
+ (x, y)
+}
+
+fn main() {
+ // test that deref patterns can move out of boxes
+ let b1 = Box::new(0);
+ let b2 = Box::new((0,));
+ assert_eq!(unbox_1(b1), unbox_2(b2));
+ let b3 = Box::new((1, 2));
+ assert_eq!(unbox_separately(b3), (1, 2));
+
+ // test that borrowing from a box also works
+ let mut b = "hi".to_owned().into_boxed_str();
+ let deref!(ref mut s) = b else { unreachable!() };
+ s.make_ascii_uppercase();
+ assert_eq!(&*b, "HI");
+}
diff --git a/tests/ui/pattern/deref-patterns/fake_borrows.rs b/tests/ui/pattern/deref-patterns/fake_borrows.rs
index bf614d7d66fda..fba2873fd02a3 100644
--- a/tests/ui/pattern/deref-patterns/fake_borrows.rs
+++ b/tests/ui/pattern/deref-patterns/fake_borrows.rs
@@ -3,6 +3,23 @@
#[rustfmt::skip]
fn main() {
+ let mut v = vec![false];
+ match v {
+ deref!([true]) => {}
+ _ if { v[0] = true; false } => {}
+ //~^ ERROR cannot borrow `v` as mutable because it is also borrowed as immutable
+ deref!([false]) => {}
+ _ => {},
+ }
+ match v {
+ [true] => {}
+ _ if { v[0] = true; false } => {}
+ //~^ ERROR cannot borrow `v` as mutable because it is also borrowed as immutable
+ [false] => {}
+ _ => {},
+ }
+
+ // deref patterns on boxes are lowered specially; test them separately.
let mut b = Box::new(false);
match b {
deref!(true) => {}
diff --git a/tests/ui/pattern/deref-patterns/fake_borrows.stderr b/tests/ui/pattern/deref-patterns/fake_borrows.stderr
index 8c060236d0dfe..7dc3001739e67 100644
--- a/tests/ui/pattern/deref-patterns/fake_borrows.stderr
+++ b/tests/ui/pattern/deref-patterns/fake_borrows.stderr
@@ -1,6 +1,28 @@
-error[E0510]: cannot assign `*b` in match guard
+error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
--> $DIR/fake_borrows.rs:9:16
|
+LL | match v {
+ | - immutable borrow occurs here
+LL | deref!([true]) => {}
+LL | _ if { v[0] = true; false } => {}
+ | ^ - immutable borrow later used here
+ | |
+ | mutable borrow occurs here
+
+error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
+ --> $DIR/fake_borrows.rs:16:16
+ |
+LL | match v {
+ | - immutable borrow occurs here
+LL | [true] => {}
+LL | _ if { v[0] = true; false } => {}
+ | ^ - immutable borrow later used here
+ | |
+ | mutable borrow occurs here
+
+error[E0510]: cannot assign `*b` in match guard
+ --> $DIR/fake_borrows.rs:26:16
+ |
LL | match b {
| - value is immutable in match guard
LL | deref!(true) => {}
@@ -8,7 +30,7 @@ LL | _ if { *b = true; false } => {}
| ^^^^^^^^^ cannot assign
error[E0510]: cannot assign `*b` in match guard
- --> $DIR/fake_borrows.rs:16:16
+ --> $DIR/fake_borrows.rs:33:16
|
LL | match b {
| - value is immutable in match guard
@@ -16,6 +38,7 @@ LL | true => {}
LL | _ if { *b = true; false } => {}
| ^^^^^^^^^ cannot assign
-error: aborting due to 2 previous errors
+error: aborting due to 4 previous errors
-For more information about this error, try `rustc --explain E0510`.
+Some errors have detailed explanations: E0502, E0510.
+For more information about an error, try `rustc --explain E0502`.
diff --git a/tests/ui/pattern/deref-patterns/implicit-cow-deref.rs b/tests/ui/pattern/deref-patterns/implicit-cow-deref.rs
index a9b8de8601078..04c83d4c33fd0 100644
--- a/tests/ui/pattern/deref-patterns/implicit-cow-deref.rs
+++ b/tests/ui/pattern/deref-patterns/implicit-cow-deref.rs
@@ -4,6 +4,7 @@
#![allow(incomplete_features)]
use std::borrow::Cow;
+use std::rc::Rc;
fn main() {
let cow: Cow<'static, [u8]> = Cow::Borrowed(&[1, 2, 3]);
@@ -18,7 +19,7 @@ fn main() {
Cow::Owned(_) => unreachable!(),
}
- match Box::new(&cow) {
+ match Rc::new(&cow) {
Cow::Borrowed { 0: _ } => {}
Cow::Owned { 0: _ } => unreachable!(),
_ => unreachable!(),
@@ -37,7 +38,7 @@ fn main() {
Cow::Owned(_) => {}
}
- match Box::new(&cow_of_cow) {
+ match Rc::new(&cow_of_cow) {
Cow::Borrowed { 0: _ } => unreachable!(),
Cow::Owned { 0: _ } => {}
_ => unreachable!(),