1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
//! build.rs file to obtain the host information.
// Allow dead code in triple.rs and targets.rs for our purposes here.
#![allow(dead_code)]
use std::env;
use std::fs::File;
use std::io::{self, Write};
use std::path::PathBuf;
use std::process::Command;
use std::str::FromStr;
#[cfg(not(feature = "std"))]
extern crate alloc;
#[cfg(feature = "std")]
extern crate std as alloc;
// Include triple.rs and targets.rs so we can parse the TARGET environment variable.
// targets.rs depends on data_model
mod data_model {
include!("src/data_model.rs");
}
mod triple {
include!("src/triple.rs");
}
mod targets {
include!("src/targets.rs");
}
// Stub out `ParseError` to minimally support triple.rs and targets.rs.
mod parse_error {
#[derive(Debug)]
pub enum ParseError {
UnrecognizedArchitecture(String),
UnrecognizedVendor(String),
UnrecognizedOperatingSystem(String),
UnrecognizedEnvironment(String),
UnrecognizedBinaryFormat(String),
UnrecognizedField(String),
}
}
use self::targets::Vendor;
use self::triple::Triple;
fn main() {
let out_dir = PathBuf::from(
env::var_os("OUT_DIR").expect("The OUT_DIR environment variable must be set"),
);
let target = env::var("TARGET").expect("The TARGET environment variable must be set");
let triple =
Triple::from_str(&target).unwrap_or_else(|_| panic!("Invalid target name: '{}'", target));
let out = File::create(out_dir.join("host.rs")).expect("error creating host.rs");
write_host_rs(out, triple).expect("error writing host.rs");
if using_1_40() {
println!("cargo:rustc-cfg=feature=\"rust_1_40\"");
}
}
fn using_1_40() -> bool {
match (|| {
let rustc = env::var_os("RUSTC").unwrap();
let output = Command::new(rustc).arg("--version").output().ok()?;
let stdout = if output.status.success() {
output.stdout
} else {
return None;
};
std::str::from_utf8(&stdout)
.ok()?
.split(' ')
.nth(1)?
.split('.')
.nth(1)?
.parse::<i32>()
.ok()
})() {
Some(version) => version >= 40,
None => true, // assume we're using an up-to-date compiler
}
}
fn write_host_rs(mut out: File, triple: Triple) -> io::Result<()> {
// The generated Debug implementation for the inner architecture variants
// doesn't print the enum name qualifier, so import them here. There
// shouldn't be any conflicts because these enums all share a namespace
// in the triple string format.
writeln!(
out,
r#"
#[allow(unused_imports)]
use crate::Aarch64Architecture::*;
#[allow(unused_imports)]
use crate::ArmArchitecture::*;
#[allow(unused_imports)]
use crate::CustomVendor;
#[allow(unused_imports)]
use crate::Mips32Architecture::*;
#[allow(unused_imports)]
use crate::Mips64Architecture::*;
#[allow(unused_imports)]
use crate::Riscv32Architecture::*;
#[allow(unused_imports)]
use crate::Riscv64Architecture::*;
#[allow(unused_imports)]
use crate::X86_32Architecture::*;
/// The `Triple` of the current host.
pub const HOST: Triple = Triple {{
architecture: Architecture::{architecture:?},
vendor: Vendor::{vendor},
operating_system: OperatingSystem::{operating_system:?},
environment: Environment::{environment:?},
binary_format: BinaryFormat::{binary_format:?},
}};
impl Architecture {{
/// Return the architecture for the current host.
pub const fn host() -> Self {{
Architecture::{architecture:?}
}}
}}
impl Vendor {{
/// Return the vendor for the current host.
pub const fn host() -> Self {{
Vendor::{vendor}
}}
}}
impl OperatingSystem {{
/// Return the operating system for the current host.
pub const fn host() -> Self {{
OperatingSystem::{operating_system:?}
}}
}}
impl Environment {{
/// Return the environment for the current host.
pub const fn host() -> Self {{
Environment::{environment:?}
}}
}}
impl BinaryFormat {{
/// Return the binary format for the current host.
pub const fn host() -> Self {{
BinaryFormat::{binary_format:?}
}}
}}
impl Triple {{
/// Return the triple for the current host.
pub const fn host() -> Self {{
Self {{
architecture: Architecture::{architecture:?},
vendor: Vendor::{vendor},
operating_system: OperatingSystem::{operating_system:?},
environment: Environment::{environment:?},
binary_format: BinaryFormat::{binary_format:?},
}}
}}
}}"#,
architecture = triple.architecture,
vendor = vendor_display(&triple.vendor),
operating_system = triple.operating_system,
environment = triple.environment,
binary_format = triple.binary_format,
)?;
Ok(())
}
fn vendor_display(vendor: &Vendor) -> String {
match vendor {
Vendor::Custom(custom) => format!("Custom(CustomVendor::Static({:?}))", custom.as_str()),
known => format!("{:?}", known),
}
}
|
