rustc: Add target_has_floating_point property

This adds a new target property, `target_has_floating_point` which can be used as a matcher for conditional compilation. The default value is `true`.

Matching against the `target_has_floating_point` attribute with `#[cfg]` is currently feature gated as `cfg_target_has_floating_point`.

Author: phil-opp

src/doc/reference.md

@@ -2087,6 +2087,7 @@ The following configurations must be defined by the implementation:
   64-bit pointers.
 * `target_vendor = "..."` - Vendor of the target, for example `apple`, `pc`, or
   simply `"unknown"`.
+* `target_has_floating_point` - Enabled if the target supports floating point operations.
 * `test` - Enabled when compiling the test harness (using the `--test` flag).
 * `unix` - See `target_family`.
 * `windows` - See `target_family`.
@@ -2287,6 +2288,9 @@ The currently implemented features of the reference compiler are:
 * `cfg_target_vendor` - Allows conditional compilation using the `target_vendor`
                         matcher which is subject to change.
 
+* `cfg_target_has_floating_point` - Allows conditional compilation using the
+                                   `target_has_floating_point` matcher which is subject to change.
+
 * `concat_idents` - Allows use of the `concat_idents` macro, which is in many
                     ways insufficient for concatenating identifiers, and may be
                     removed entirely for something more wholesome.

src/librustc/session/config.rs

@@ -710,6 +710,9 @@ pub fn default_configuration(sess: &Session) -> ast::CrateConfig {
     if sess.target.target.options.has_elf_tls {
         ret.push(attr::mk_word_item(InternedString::new("target_thread_local")));
     }
+    if sess.target.target.options.has_floating_point {
+        ret.push(attr::mk_word_item(InternedString::new("target_has_floating_point")));
+    }
     if sess.opts.debug_assertions {
         ret.push(attr::mk_word_item(InternedString::new("debug_assertions")));
     }

src/librustc_back/target/mod.rs

@@ -287,6 +287,9 @@ pub struct TargetOptions {
     // If we give emcc .o files that are actually .bc files it
     // will 'just work'.
     pub obj_is_bitcode: bool,
+
+    /// Flag indicating whether the target supports floating point instructions. Defaults to true.
+    pub has_floating_point: bool,
 }
 
 impl Default for TargetOptions {
@@ -335,6 +338,7 @@ impl Default for TargetOptions {
             allow_asm: true,
             has_elf_tls: false,
             obj_is_bitcode: false,
+            has_floating_point: true,
         }
     }
 }
@@ -445,6 +449,7 @@ impl Target {
         key!(archive_format);
         key!(allow_asm, bool);
         key!(custom_unwind_resume, bool);
+        key!(has_floating_point, bool);
 
         base
     }

src/libsyntax/feature_gate.rs

@@ -256,6 +256,9 @@ const KNOWN_FEATURES: &'static [(&'static str, &'static str, Option<u32>, Status
 
     // impl specialization (RFC 1210)
     ("specialization", "1.7.0", Some(31844), Active),
+
+    // Allows cfg(target_has_floating_point)
+    ("cfg_target_has_floating_point", "1.9.0", None, Active),
 ];
 // (changing above list without updating src/doc/reference.md makes @cmr sad)
 
@@ -460,6 +463,8 @@ const GATED_CFGS: &'static [(&'static str, &'static str, fn(&Features) -> bool)]
     ("target_vendor", "cfg_target_vendor", cfg_fn!(|x| x.cfg_target_vendor)),
     ("target_thread_local", "cfg_target_thread_local",
      cfg_fn!(|x| x.cfg_target_thread_local)),
+    ("target_has_floating_point", "cfg_target_has_floating_point",
+     cfg_fn!(|x| x.cfg_target_has_floating_point)),
 ];
 
 #[derive(Debug, Eq, PartialEq)]
@@ -595,6 +600,7 @@ pub struct Features {
     pub cfg_target_feature: bool,
     pub cfg_target_vendor: bool,
     pub cfg_target_thread_local: bool,
+    pub cfg_target_has_floating_point: bool,
     pub staged_api: bool,
     pub stmt_expr_attributes: bool,
     pub deprecated: bool,
@@ -631,6 +637,7 @@ impl Features {
             cfg_target_feature: false,
             cfg_target_vendor: false,
             cfg_target_thread_local: false,
+            cfg_target_has_floating_point: true,
             staged_api: false,
             stmt_expr_attributes: false,
             deprecated: false,
@@ -1243,6 +1250,7 @@ fn check_crate_inner<F>(cm: &CodeMap, span_handler: &Handler,
         cfg_target_feature: cx.has_feature("cfg_target_feature"),
         cfg_target_vendor: cx.has_feature("cfg_target_vendor"),
         cfg_target_thread_local: cx.has_feature("cfg_target_thread_local"),
+        cfg_target_has_floating_point: cx.has_feature("cfg_target_has_floating_point"),
         staged_api: cx.has_feature("staged_api"),
         stmt_expr_attributes: cx.has_feature("stmt_expr_attributes"),
         deprecated: cx.has_feature("deprecated"),

src/test/compile-fail/feature-gate-cfg-target-has-floating-point.rs

@@ -0,0 +1,23 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(target_has_floating_point)] //~ ERROR `cfg(target_has_floating_point)` is experimental
+#[cfg_attr(target_has_floating_point, repr(C))]
+//~^ ERROR `cfg(target_has_floating_point)` is experimental
+struct Foo(u64, u64);
+
+#[cfg(not(any(all(target_has_floating_point))))]
+//~^ ERROR `cfg(target_has_floating_point)` is experimental
+fn foo() {}
+
+fn main() {
+    cfg!(target_has_floating_point);
+    //~^ ERROR `cfg(target_has_floating_point)` is experimental and subject to change
+}

src/test/run-pass/cfg-target-has-floating-point.rs

@@ -0,0 +1,19 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(cfg_target_has_floating_point)]
+
+#[cfg(target_has_floating_point)]
+pub fn main() {
+}
+
+#[cfg(not(target_has_floating_point))]
+pub fn main() {
+}