aboutsummaryrefslogtreecommitdiff
path: root/libbuild2/cc/module.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'libbuild2/cc/module.cxx')
-rw-r--r--libbuild2/cc/module.cxx284
1 files changed, 165 insertions, 119 deletions
diff --git a/libbuild2/cc/module.cxx b/libbuild2/cc/module.cxx
index 641da5e..5f8652e 100644
--- a/libbuild2/cc/module.cxx
+++ b/libbuild2/cc/module.cxx
@@ -51,89 +51,114 @@ namespace build2
// config.x
//
-
- // Normally we will have a persistent configuration and computing the
- // default value every time will be a waste. So try without a default
- // first.
- //
- auto p (config::omitted (rs, config_x));
-
- if (!p.first)
+ strings mode;
{
- // If there is a config.x value for one of the modules that can hint
- // us the toolchain, load it's .guess module. This makes sure that the
- // order in which we load the modules is unimportant and that the user
- // can specify the toolchain using any of the config.x values.
+ // Normally we will have a persistent configuration and computing the
+ // default value every time will be a waste. So try without a default
+ // first.
//
- if (!cc_loaded)
+ auto p (config::omitted (rs, config_x));
+
+ if (!p.first)
{
- for (const char* const* pm (x_hinters); *pm != nullptr; ++pm)
+ // If there is a config.x value for one of the modules that can hint
+ // us the toolchain, load it's .guess module. This makes sure that
+ // the order in which we load the modules is unimportant and that
+ // the user can specify the toolchain using any of the config.x
+ // values.
+ //
+ if (!cc_loaded)
{
- string m (*pm);
+ for (const char* const* pm (x_hinters); *pm != nullptr; ++pm)
+ {
+ string m (*pm);
- // Must be the same as in module's init().
- //
- const variable& v (vp.insert<path> ("config." + m, true));
+ // Must be the same as in module's init().
+ //
+ const variable& v (vp.insert<strings> ("config." + m, true));
- if (rs[v].defined ())
- {
- load_module (rs, rs, m + ".guess", loc);
- cc_loaded = true;
- break;
+ if (rs[v].defined ())
+ {
+ load_module (rs, rs, m + ".guess", loc);
+ cc_loaded = true;
+ break;
+ }
}
}
+
+ // If cc.core.config is already loaded then use its toolchain id,
+ // (optional) pattern, and mode to guess an appropriate default
+ // (e.g., for {gcc, *-4.9 -m64} we will get g++-4.9 -m64).
+ //
+ strings d;
+
+ if (cc_loaded)
+ d = guess_default (x_lang,
+ cast<string> (rs["cc.id"]),
+ cast<string> (rs["cc.pattern"]),
+ cast<strings> (rs["cc.mode"]));
+ else
+ {
+ // Note that we don't have the default mode: it doesn't feel
+ // correct to default to, say, -m64 simply because that's how
+ // build2 was built.
+ //
+ d.push_back (x_default);
+
+ if (d.front ().empty ())
+ fail << "not built with default " << x_lang << " compiler" <<
+ info << "use " << config_x << " to specify";
+ }
+
+ // If this value was hinted, save it as commented out so that if the
+ // user changes the source of the pattern/mode, this one will get
+ // updated as well.
+ //
+ p = config::required (rs,
+ config_x,
+ move (d),
+ false,
+ cc_loaded ? config::save_commented : 0);
}
- // If cc.core.config is already loaded then use its toolchain id and
- // (optional) pattern to guess an appropriate default (e.g., for {gcc,
- // *-4.9} we will get g++-4.9).
+ // Split the value into the compiler path and mode.
//
- path d;
+ const strings& v (cast<strings> (*p.first));
- if (cc_loaded)
- d = guess_default (x_lang,
- cast<string> (rs["cc.id"]),
- cast<string> (rs["cc.pattern"]));
- else
- {
- d = path (x_default);
+ path xc;
+ try { xc = path (v.front ()); } catch (const invalid_path&) {}
- if (d.empty ())
- fail << "not built with default " << x_lang << " compiler" <<
- info << "use config." << x << " to specify";
- }
+ if (xc.empty ())
+ fail << "invalid path '" << v.front () << "' in " << config_x;
- // If this value was hinted, save it as commented out so that if the
- // user changes the source of the pattern, this one will get updated
- // as well.
+ mode.assign (++v.begin (), v.end ());
+
+ // Figure out which compiler we are dealing with, its target, etc.
+ //
+ // Note that we could allow guess() to modify mode to support
+ // imaginary options (such as /MACHINE for cl.exe). Though it's not
+ // clear what cc.mode would contain (original or modified).
//
- p = config::required (rs,
- config_x,
- d,
- false,
- cc_loaded ? config::save_commented : 0);
+ x_info = &build2::cc::guess (
+ x, x_lang, move (xc),
+ cast_null<string> (config::omitted (rs, config_x_id).first),
+ cast_null<string> (config::omitted (rs, config_x_version).first),
+ cast_null<string> (config::omitted (rs, config_x_target).first),
+ mode,
+ cast_null<strings> (rs[config_c_poptions]),
+ cast_null<strings> (rs[config_x_poptions]),
+ cast_null<strings> (rs[config_c_coptions]),
+ cast_null<strings> (rs[config_x_coptions]),
+ cast_null<strings> (rs[config_c_loptions]),
+ cast_null<strings> (rs[config_x_loptions]));
+
+ new_ = p.second;
}
- // Figure out which compiler we are dealing with, its target, etc.
- //
- x_info = &build2::cc::guess (
- x,
- x_lang,
- cast<path> (*p.first),
- cast_null<string> (config::omitted (rs, config_x_id).first),
- cast_null<string> (config::omitted (rs, config_x_version).first),
- cast_null<string> (config::omitted (rs, config_x_target).first),
- cast_null<strings> (rs[config_c_poptions]),
- cast_null<strings> (rs[config_x_poptions]),
- cast_null<strings> (rs[config_c_coptions]),
- cast_null<strings> (rs[config_x_coptions]),
- cast_null<strings> (rs[config_c_loptions]),
- cast_null<strings> (rs[config_x_loptions]));
-
const compiler_info& xi (*x_info);
- // Split/canonicalize the target. First see if the user asked us to
- // use config.sub.
+ // Split/canonicalize the target. First see if the user asked us to use
+ // config.sub.
//
target_triplet tt;
{
@@ -167,6 +192,9 @@ namespace build2
// Assign values to variables that describe the compiler.
//
+ rs.assign (x_path) = process_path (xi.path, false /* init */);
+ const strings& xm (cast<strings> (rs.assign (x_mode) = move (mode)));
+
rs.assign (x_id) = xi.id.string ();
rs.assign (x_id_type) = to_string (xi.id.type);
rs.assign (x_id_variant) = xi.id.variant;
@@ -187,6 +215,9 @@ namespace build2
assign_version (&x_variant_version,
xi.variant_version ? &*xi.variant_version : nullptr);
+ rs.assign (x_signature) = xi.signature;
+ rs.assign (x_checksum) = xi.checksum;
+
// Also enter as x.target.{cpu,vendor,system,version,class} for
// convenience of access.
//
@@ -203,8 +234,6 @@ namespace build2
if (!x_stdlib.alias (c_stdlib))
rs.assign (x_stdlib) = xi.x_stdlib;
- new_ = p.second;
-
// Load cc.core.guess.
//
if (!cc_loaded)
@@ -222,6 +251,9 @@ namespace build2
if (!xi.pattern.empty ())
h.assign ("config.cc.pattern") = xi.pattern;
+ if (!xm.empty ())
+ h.assign ("config.cc.mode") = xm;
+
h.assign (c_runtime) = xi.runtime;
h.assign (c_stdlib) = xi.c_stdlib;
@@ -262,6 +294,9 @@ namespace build2
// g++-7 vs gcc kind of mistakes. So now we warn since even if
// intentional, it is still probably a bad idea.
//
+ // Note also that it feels right to allow different modes (think
+ // -fexceptions for C or -fno-rtti for C++).
+ //
check (cast<string> (rs["cc.pattern"]),
cast<string> (rs[x_pattern]),
"toolchain pattern",
@@ -299,6 +334,37 @@ namespace build2
const compiler_info& xi (*x_info);
const target_triplet& tt (cast<target_triplet> (rs[x_target]));
+ // config.x.{p,c,l}options
+ // config.x.libs
+ //
+ // These are optional. We also merge them into the corresponding
+ // x.* variables.
+ //
+ // The merging part gets a bit tricky if this module has already
+ // been loaded in one of the outer scopes. By doing the straight
+ // append we would just be repeating the same options over and
+ // over. So what we are going to do is only append to a value if
+ // it came from this scope. Then the usage for merging becomes:
+ //
+ // x.coptions = <overridable options> # Note: '='.
+ // using x
+ // x.coptions += <overriding options> # Note: '+='.
+ //
+ rs.assign (x_poptions) += cast_null<strings> (
+ config::optional (rs, config_x_poptions));
+
+ rs.assign (x_coptions) += cast_null<strings> (
+ config::optional (rs, config_x_coptions));
+
+ rs.assign (x_loptions) += cast_null<strings> (
+ config::optional (rs, config_x_loptions));
+
+ rs.assign (x_aoptions) += cast_null<strings> (
+ config::optional (rs, config_x_aoptions));
+
+ rs.assign (x_libs) += cast_null<strings> (
+ config::optional (rs, config_x_libs));
+
// config.x.std overrides x.std
//
{
@@ -318,6 +384,22 @@ namespace build2
tstd = translate_std (xi, rs, v);
}
+ // config.x.translatable_header
+ //
+ // It's still fuzzy whether specifying (or maybe tweaking) this list in
+ // the configuration will be a common thing to do so for now we use
+ // omitted. It's also probably too early to think whether we should have
+ // the cc.* version and what the semantics should be.
+ //
+ if (x_translatable_headers != nullptr)
+ {
+ lookup l (config::omitted (rs, *config_x_translatable_headers).first);
+
+ // @@ MODHDR: if(modules) ?
+ //
+ rs.assign (x_translatable_headers) += cast_null<strings> (l);
+ }
+
// Extract system header/library search paths from the compiler and
// determine if we need any additional search paths.
//
@@ -443,12 +525,27 @@ namespace build2
//
if (verb >= (new_ ? 2 : 3))
{
+ const strings& mode (cast<strings> (rs[x_mode]));
+
diag_record dr (text);
{
dr << x << ' ' << project (rs) << '@' << rs << '\n'
- << " " << left << setw (11) << x << xi.path << '\n'
- << " id " << xi.id << '\n'
+ << " " << left << setw (11) << x << xi.path << '\n';
+ }
+
+ if (!mode.empty ())
+ {
+ dr << " mode "; // One space short.
+
+ for (const string& o: mode)
+ dr << ' ' << o;
+
+ dr << '\n';
+ }
+
+ {
+ dr << " id " << xi.id << '\n'
<< " version " << xi.version.string << '\n'
<< " major " << xi.version.major << '\n'
<< " minor " << xi.version.minor << '\n'
@@ -525,60 +622,9 @@ namespace build2
}
}
- rs.assign (x_path) = process_path (xi.path, false /* init */);
rs.assign (x_sys_lib_dirs) = move (lib_dirs);
rs.assign (x_sys_inc_dirs) = move (inc_dirs);
- rs.assign (x_signature) = xi.signature;
- rs.assign (x_checksum) = xi.checksum;
-
- // config.x.{p,c,l}options
- // config.x.libs
- //
- // These are optional. We also merge them into the corresponding
- // x.* variables.
- //
- // The merging part gets a bit tricky if this module has already
- // been loaded in one of the outer scopes. By doing the straight
- // append we would just be repeating the same options over and
- // over. So what we are going to do is only append to a value if
- // it came from this scope. Then the usage for merging becomes:
- //
- // x.coptions = <overridable options> # Note: '='.
- // using x
- // x.coptions += <overriding options> # Note: '+='.
- //
- rs.assign (x_poptions) += cast_null<strings> (
- config::optional (rs, config_x_poptions));
-
- rs.assign (x_coptions) += cast_null<strings> (
- config::optional (rs, config_x_coptions));
-
- rs.assign (x_loptions) += cast_null<strings> (
- config::optional (rs, config_x_loptions));
-
- rs.assign (x_aoptions) += cast_null<strings> (
- config::optional (rs, config_x_aoptions));
-
- rs.assign (x_libs) += cast_null<strings> (
- config::optional (rs, config_x_libs));
-
- // config.x.translatable_header
- //
- // It's still fuzzy whether specifying (or maybe tweaking) this list in
- // the configuration will be a common thing to do so for now we use
- // omitted. It's also probably too early to think whether we should have
- // the cc.* version and what the semantics should be.
- //
- if (x_translatable_headers != nullptr)
- {
- lookup l (config::omitted (rs, *config_x_translatable_headers).first);
-
- // @@ MODHDR: if(modules) ?
- //
- rs.assign (x_translatable_headers) += cast_null<strings> (l);
- }
-
// Load cc.core.config.
//
if (!cast_false<bool> (rs["cc.core.config.loaded"]))