Implementation of target_api_features

Author: seritools

src/doc/rustc/src/codegen-options/index.md

@@ -480,6 +480,33 @@ point instructions in software. It takes one of the following values:
 * `y`, `yes`, `on`, or no value: use soft floats.
 * `n`, `no`, or `off`: use hardware floats (the default).
 
+## target-api-features
+
+This option tells `rustc` which operating system APIs are expected to be supported for the target.
+Implied features are added as well.
+
+#### Windows
+
+Currently, this option is only used for Windows targets, where the feature
+names are the `<major>.<minor>.<build>` versions of all major releases (e.g. `10.0.10240`).
+Any version selected adds all previous versions as well, allowing for "greater than"
+comparisons:
+
+```rs
+if cfg!(target_api_feature = "10.0.10240") {
+    println!("new win10 api here");
+} else if cfg!(target_api_feature = "6.1.7600") {
+    println!("regular win7 api here");
+} else if cfg!(target_api_feature = "5.1.2600") {
+    println!("legacy winxp api here");
+} else {
+    println!("not supported");
+}
+```
+
+Currently, the default for regular Windows targets is Windows 7 (`6.1.7600`).
+For UWP targets, it is Windows 10, Version 1509 (`10.0.10240`).
+
 ## target-cpu
 
 This instructs `rustc` to generate code specifically for a particular processor.

src/librustc_interface/Cargo.toml

@@ -44,6 +44,7 @@ rustc_privacy = { path = "../librustc_privacy" }
 rustc_resolve = { path = "../librustc_resolve" }
 rustc_trait_selection = { path = "../librustc_trait_selection" }
 rustc_ty = { path = "../librustc_ty" }
+rustc_target = { path = "../librustc_target" }
 tempfile = "3.0.5"
 once_cell = "1"
 

src/librustc_interface/tests.rs

@@ -444,6 +444,7 @@ fn test_codegen_options_tracking_hash() {
     tracked!(profile_use, Some(PathBuf::from("abc")));
     tracked!(relocation_model, Some(RelocModel::Pic));
     tracked!(soft_float, true);
+    tracked!(target_api_features, Some(vec![String::from("1"), String::from("2")]));
     tracked!(target_cpu, Some(String::from("abc")));
     tracked!(target_feature, String::from("all the features, all of them"));
 }

src/librustc_interface/util.rs

@@ -53,6 +53,22 @@ pub fn add_configuration(
     if sess.crt_static(None) {
         cfg.insert((tf, Some(sym::crt_dash_static)));
     }
+
+    let target_options = &sess.target.target.options;
+    if let Some(target_api_kind) = &target_options.target_api_kind {
+        let target_api_defaults = &target_options.target_api_default_features;
+        let selected_target_apis =
+            sess.opts.cg.target_api_features.as_ref().unwrap_or(target_api_defaults);
+
+        let apis = rustc_target::api::get_enabled_target_api_features(
+            target_api_kind,
+            selected_target_apis,
+        );
+
+        let ta = sym::target_api_feature;
+        cfg.extend(apis.into_iter().map(|api| (ta, Some(Symbol::intern(api)))));
+        cfg.extend(selected_target_apis.into_iter().map(|api| (ta, Some(Symbol::intern(api)))));
+    }
 }
 
 pub fn create_session(

src/librustc_session/options.rs

@@ -768,6 +768,8 @@ options! {CodegenOptions, CodegenSetter, basic_codegen_options,
         "save all temporary output files during compilation (default: no)"),
     soft_float: bool = (false, parse_bool, [TRACKED],
         "use soft float ABI (*eabihf targets only) (default: no)"),
+    target_api_features: Option<Vec<String>> = (None, parse_opt_list, [TRACKED],
+        "a list of target APIs that are expected to be be available on the target (default: use target default)"),
     target_cpu: Option<String> = (None, parse_opt_string, [TRACKED],
         "select target processor (`rustc --print target-cpus` for details)"),
     target_feature: String = (String::new(), parse_target_feature, [TRACKED],

src/librustc_span/symbol.rs

@@ -1061,6 +1061,7 @@ symbols! {
         sym,
         sync,
         sync_trait,
+        target_api_feature,
         target_arch,
         target_endian,
         target_env,

src/librustc_target/api/mod.rs

@@ -0,0 +1,11 @@
+pub mod windows;
+
+pub fn get_enabled_target_api_features(
+    target_kind: &str,
+    requested_apis: &[String],
+) -> Vec<&'static str> {
+    match target_kind {
+        "windows" => windows::get_enabled_target_api_features(requested_apis),
+        _ => vec![],
+    }
+}

src/librustc_target/api/windows.rs

@@ -0,0 +1,39 @@
+const WINDOWS_VERSIONS: [&str; 25] = [
+    "3.10.511",   // NT 3.1
+    "3.50.807",   // NT 3.5
+    "3.51.1057",  // NT 3.51
+    "4.0.1381",   // NT 4
+    "5.0.2195",   // 2000
+    "5.1.2600",   // XP
+    "5.2.3790",   // XP 64bit, Server 2003
+    "6.0.6000",   // Vista, Server 2008
+    "6.0.6001",   // Vista SP1, Server 2008 SP1
+    "6.0.6002",   // Vista SP2, Server 2008 SP2
+    "6.1.7600",   // 7, Server 2008 R2
+    "6.1.7601",   // 7 SP1, Server 2008 R2 SP1
+    "6.1.8400",   // Home Server 2011
+    "6.2.9200",   // 8, Server 2012
+    "6.3.9600",   // 8.1, Server 2012 R2
+    "10.0.10240", // 10 1507
+    "10.0.10586", // 10 1511
+    "10.0.14393", // 10 1607, Server 2016 1607
+    "10.0.15063", // 10 1703
+    "10.0.16299", // 10 1709, Server 2016 1709
+    "10.0.17134", // 10 1803
+    "10.0.17763", // 10 1809, Server 2019 1809
+    "10.0.18362", // 10 1903
+    "10.0.18363", // 10 1909
+    "10.0.19041", // 10 2004
+];
+
+pub fn get_enabled_target_api_features(requested_apis: &[String]) -> Vec<&'static str> {
+    let highest_index = requested_apis.iter().fold(None, |old_highest_index, api| {
+        if let Some((index, _)) = WINDOWS_VERSIONS.iter().enumerate().find(|&(_, ver)| ver == api) {
+            old_highest_index.map(|old_index| std::cmp::max(old_index, index)).or(Some(index))
+        } else {
+            old_highest_index
+        }
+    });
+
+    highest_index.map(|i| WINDOWS_VERSIONS[..=i].into()).unwrap_or(vec![])
+}

src/librustc_target/lib.rs

@@ -23,6 +23,7 @@ extern crate rustc_macros;
 extern crate tracing;
 
 pub mod abi;
+pub mod api;
 pub mod asm;
 pub mod spec;
 

src/librustc_target/spec/mod.rs

@@ -993,6 +993,12 @@ pub struct TargetOptions {
     /// used to locate unwinding information is passed
     /// (only has effect if the linker is `ld`-like).
     pub eh_frame_header: bool,
+
+    /// Decides which logic will be used for determining the full set of target API features
+    pub target_api_kind: Option<String>,
+
+    /// The default API features for this target.
+    pub target_api_default_features: Vec<String>,
 }
 
 impl Default for TargetOptions {
@@ -1085,6 +1091,8 @@ impl Default for TargetOptions {
             llvm_args: vec![],
             use_ctors_section: false,
             eh_frame_header: true,
+            target_api_kind: None,
+            target_api_default_features: vec![],
         }
     }
 }
@@ -1478,6 +1486,8 @@ impl Target {
         key!(llvm_args, list);
         key!(use_ctors_section, bool);
         key!(eh_frame_header, bool);
+        key!(target_api_kind, optional);
+        key!(target_api_default_features, list);
 
         // NB: The old name is deprecated, but support for it is retained for
         // compatibility.
@@ -1716,6 +1726,8 @@ impl ToJson for Target {
         target_option_val!(llvm_args);
         target_option_val!(use_ctors_section);
         target_option_val!(eh_frame_header);
+        target_option_val!(target_api_kind);
+        target_option_val!(target_api_default_features);
 
         if default.unsupported_abis != self.options.unsupported_abis {
             d.insert(
@@ -1791,3 +1803,10 @@ impl fmt::Display for TargetTriple {
         write!(f, "{}", self.debug_triple())
     }
 }
+
+/// A target api function and an optional default, if any
+#[derive(PartialEq, Clone, Debug)]
+pub struct TargetApiDefinition {
+    pub api_kind: String,
+    pub target_api_default_features: Vec<String>,
+}