]>
git.proxmox.com Git - rustc.git/blob - src/bootstrap/cc.rs
1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! C-compiler probing and detection.
13 //! This module will fill out the `cc` and `cxx` maps of `Build` by looking for
14 //! C and C++ compilers for each target configured. A compiler is found through
15 //! a number of vectors (in order of precedence)
17 //! 1. Configuration via `target.$target.cc` in `config.toml`.
18 //! 2. Configuration via `target.$target.android-ndk` in `config.toml`, if
20 //! 3. Special logic to probe on OpenBSD
21 //! 4. The `CC_$target` environment variable.
22 //! 5. The `CC` environment variable.
25 //! Some of this logic is implemented here, but much of it is farmed out to the
26 //! `gcc` crate itself, so we end up having the same fallbacks as there.
27 //! Similar logic is then used to find a C++ compiler, just some s/cc/c++/ is
30 //! It is intended that after this module has run no C/C++ compiler will
31 //! ever be probed for. Instead the compilers found here will be used for
34 use std
::process
::Command
;
36 use build_helper
::{cc2ar, output}
;
42 pub fn find(build
: &mut Build
) {
43 // For all targets we're going to need a C compiler for building some shims
44 // and such as well as for being a linker for Rust code.
45 for target
in build
.config
.target
.iter() {
46 let mut cfg
= gcc
::Config
::new();
47 cfg
.cargo_metadata(false).opt_level(0).debug(false)
48 .target(target
).host(&build
.config
.build
);
50 let config
= build
.config
.target_config
.get(target
);
51 if let Some(cc
) = config
.and_then(|c
| c
.cc
.as_ref()) {
54 set_compiler(&mut cfg
, "gcc", target
, config
);
57 let compiler
= cfg
.get_compiler();
58 let ar
= cc2ar(compiler
.path(), target
);
59 build
.verbose(&format
!("CC_{} = {:?}", target
, compiler
.path()));
60 if let Some(ref ar
) = ar
{
61 build
.verbose(&format
!("AR_{} = {:?}", target
, ar
));
63 build
.cc
.insert(target
.to_string(), (compiler
, ar
));
66 // For all host triples we need to find a C++ compiler as well
67 for host
in build
.config
.host
.iter() {
68 let mut cfg
= gcc
::Config
::new();
69 cfg
.cargo_metadata(false).opt_level(0).debug(false).cpp(true)
70 .target(host
).host(&build
.config
.build
);
71 let config
= build
.config
.target_config
.get(host
);
72 if let Some(cxx
) = config
.and_then(|c
| c
.cxx
.as_ref()) {
75 set_compiler(&mut cfg
, "g++", host
, config
);
77 let compiler
= cfg
.get_compiler();
78 build
.verbose(&format
!("CXX_{} = {:?}", host
, compiler
.path()));
79 build
.cxx
.insert(host
.to_string(), compiler
);
83 fn set_compiler(cfg
: &mut gcc
::Config
,
86 config
: Option
<&Target
>) {
88 // When compiling for android we may have the NDK configured in the
89 // config.toml in which case we look there. Otherwise the default
90 // compiler already takes into account the triple in question.
91 t
if t
.contains("android") => {
92 if let Some(ndk
) = config
.and_then(|c
| c
.ndk
.as_ref()) {
93 let target
= target
.replace("armv7", "arm");
94 let compiler
= format
!("{}-{}", target
, gnu_compiler
);
95 cfg
.compiler(ndk
.join("bin").join(compiler
));
99 // The default gcc version from OpenBSD may be too old, try using egcc,
100 // which is a gcc version from ports, if this is the case.
101 t
if t
.contains("openbsd") => {
102 let c
= cfg
.get_compiler();
103 if !c
.path().ends_with(gnu_compiler
) {
107 let output
= output(c
.to_command().arg("--version"));
108 let i
= match output
.find(" 4.") {
112 match output
[i
+ 3..].chars().next().unwrap() {
116 let alternative
= format
!("e{}", gnu_compiler
);
117 if Command
::new(&alternative
).output().is_ok() {
118 cfg
.compiler(alternative
);