Add a way to get the target triple, and do our best guess at it until we have proper clang support.

Author: emilio

build.rs

@@ -1,6 +1,8 @@
 mod codegen {
     extern crate quasi_codegen;
     use std::env;
+    use std::fs::File;
+    use std::io::Write;
     use std::path::{Path, PathBuf};
 
     pub fn main() {
@@ -13,6 +15,10 @@ mod codegen {
         println!("cargo:rerun-if-changed=src/codegen/error.rs");
         println!("cargo:rerun-if-changed=src/codegen/helpers.rs");
         println!("cargo:rerun-if-changed=src/codegen/struct_layout.rs");
+
+        let mut dst =
+            File::create(Path::new(&out_dir).join("host-target.txt")).unwrap();
+        dst.write_all(env::var("TARGET").unwrap().as_bytes()).unwrap();
     }
 }
 

src/ir/context.rs

@@ -139,6 +139,9 @@ pub struct BindgenContext<'ctx> {
     /// The active replacements collected from replaces="xxx" annotations.
     replacements: HashMap<Vec<String>, ItemId>,
 
+    /// The target string bindgen was able to deduce from the input.
+    effective_target: String,
+
     collected_typerefs: bool,
 
     /// Dummy structures for code generation.
@@ -232,6 +235,32 @@ impl<'ctx> BindgenContext<'ctx> {
                                           parse_options)
                 .expect("TranslationUnit::parse failed");
 
+        // TODO(emilio): Use the CXTargetInfo here when available.
+        //
+        // see: https://reviews.llvm.org/D32389
+        let mut effective_target = None;
+        for opt in &options.clang_args {
+            if opt.starts_with("--target=") {
+                let mut split = opt.split('=');
+                split.next();
+                effective_target = Some(split.next().unwrap().to_owned());
+                break;
+            }
+        }
+
+        if effective_target.is_none() {
+            use std::env;
+            // If we're running from a build script, try to find the cargo
+            // target.
+            effective_target = env::var("TARGET").ok();
+        }
+
+        if effective_target.is_none() {
+            const HOST_TARGET: &'static str =
+                include_str!(concat!(env!("OUT_DIR"), "/host-target.txt"));
+            effective_target = Some(HOST_TARGET.to_owned());
+        }
+
         let root_module = Self::build_root_module(ItemId(0));
         let mut me = BindgenContext {
             items: Default::default(),
@@ -244,6 +273,7 @@ impl<'ctx> BindgenContext<'ctx> {
             currently_parsed_types: vec![],
             parsed_macros: Default::default(),
             replacements: Default::default(),
+            effective_target: effective_target.unwrap(),
             collected_typerefs: false,
             gen_ctx: None,
             span: DUMMY_SP,
@@ -764,6 +794,11 @@ impl<'ctx> BindgenContext<'ctx> {
         Item::new(id, None, None, id, ItemKind::Module(module))
     }
 
+    /// Returns the target triple bindgen is running over.
+    pub fn target(&self) -> &str {
+        &self.effective_target
+    }
+
     /// Get the root module.
     pub fn root_module(&self) -> ItemId {
         self.root_module