diff options
| -rw-r--r-- | build2/bin/module.cxx | 111 | ||||
| -rw-r--r-- | build2/cxx/module.cxx | 87 |
2 files changed, 169 insertions, 29 deletions
diff --git a/build2/bin/module.cxx b/build2/bin/module.cxx index 5e668df..9ce069c 100644 --- a/build2/bin/module.cxx +++ b/build2/bin/module.cxx @@ -33,6 +33,26 @@ namespace build2 static const strings liba_lib {"static"}; static const strings libso_lib {"shared"}; + // Apply the specified stem to the config.bin.pattern. If there is no + // pattern, then return the stem itself. Assume the pattern is valid, + // i.e., contains single '*'. + // + static string + apply (const lookup& pattern, const char* stem) + { + if (!pattern) + return stem; + + const string& p (cast<string> (pattern)); + size_t i (p.find ('*')); + assert (i != string::npos); + + string r (p, 0, i++); + r.append (stem); + r.append (p, i, p.size () - i); + return r; + } + bool init (scope& r, scope& b, @@ -54,6 +74,7 @@ namespace build2 // Note: some overridable, some not. // v.insert<string> ("config.bin.target", true); + v.insert<string> ("config.bin.pattern", true); v.insert<path> ("config.bin.ar", true); v.insert<path> ("config.bin.ranlib", true); @@ -76,6 +97,7 @@ namespace build2 // Configure. // using config::required; + using config::optional; // The idea here is as follows: if we already have one of // the bin.* variables set, then we assume this is static @@ -125,19 +147,21 @@ namespace build2 // See the cxx module for details on merging. // b.assign ("bin.rpath") += cast_null<dir_paths> ( - config::optional (r, "config.bin.rpath")); + optional (r, "config.bin.rpath")); if (first) { + bool new_val (false); // Set any new values? + // config.bin.target // { - const variable& cbt (var_pool.find ("config.bin.target")); + const variable& var (var_pool.find ("config.bin.target")); // We first see if the value was specified via the configuration // mechanism. // - auto p (config::required (r, cbt)); + auto p (required (r, var)); const value* v (p.first); // Then see if there is a config hint (e.g., from the C++ module). @@ -145,7 +169,7 @@ namespace build2 bool hint (false); if (v == nullptr) { - if (auto l = config_hints[cbt]) + if (auto l = config_hints[var]) { v = l.value; hint = true; @@ -154,7 +178,7 @@ namespace build2 if (v == nullptr) fail (loc) << "unable to determine binutils target" << - info << "consider specifying it with config.bin.target" << + info << "consider specifying it with " << var.name << info << "or first load a module that can provide it as a hint, " << "such as c or cxx"; @@ -202,26 +226,81 @@ namespace build2 info << "consider using the --config-sub option"; } - // If this is a new value (e.g., we are configuring), then print the - // report at verbosity level 2 and up (-v). Note that a hinted value - // will automatically only be printed at level 3 and up. + new_val = new_val || p.second; // False for a hinted value. + } + + // config.bin.pattern + // + { + const variable& var (var_pool.find ("config.bin.pattern")); + + // We first see if the value was specified via the configuration + // mechanism. // - if (verb >= (p.second ? 2 : 3)) + auto p (required (r, var)); + const value* v (p.first); + + // Then see if there is a config hint (e.g., from the C++ module). + // + if (v == nullptr) { - text << "bin\n" - << " target " << cast<string> (r["bin.target"]); + if (auto l = config_hints[var]) + v = l.value; } + + // For ease of use enter it as bin.pattern (it can come from + // different places). + // + if (v != nullptr) + { + const string& s (cast<string> (*v)); + + if (s.find ('*') == string::npos) + fail << "missing '*' in binutils pattern '" << s << "'"; + + r.assign<string> ("bin.pattern") = s; + new_val = new_val || p.second; // False for a hinted value. + } + } + + // If we set any new values (e.g., we are configuring), then print the + // report at verbosity level 2 and up (-v). + // + if (verb >= (new_val ? 2 : 3)) + { + diag_record dr (text); + + dr << "bin\n" + << " target " << cast<string> (r["bin.target"]); + + if (auto l = r["bin.pattern"]) + dr << '\n' + << " pattern " << cast<string> (l); } // config.bin.ar // config.bin.ranlib // - // For config.bin.ar we default to 'ar' while ranlib should be - // explicitly specified by the user in order for us to use it (most - // targets support the -s option to ar). + // For config.bin.ar we have the default (plus the pattern) while + // ranlib should be explicitly specified by the user in order for us + // to use it (all targets that we currently care to support have the + // ar -s option but if that changes we can always force the use of + // ranlib for certain targets). // - auto p (config::required (r, "config.bin.ar", path ("ar"))); - auto& v (config::optional (r, "config.bin.ranlib")); + // Another idea is to refuse to use default 'ar' (without the pattern) + // if the host/build targets don't match. On the other hand, a cross- + // toolchain can be target-unprefixed. Also, without canonicalization, + // comparing targets will be unreliable. + // + auto pattern (r["bin.pattern"]); + + // Use the target to decide on the default binutils program names. + // + const string& tsys (cast<string> (r["bin.target.system"])); + const char* ar_d (tsys == "win32-msvc" ? "lib" : "ar"); + + auto p (required (r, "config.bin.ar", path (apply (pattern, ar_d)))); + auto& v (optional (r, "config.bin.ranlib")); const path& ar (cast<path> (p.first)); const path& ranlib (v ? cast<path> (v) : path ()); diff --git a/build2/cxx/module.cxx b/build2/cxx/module.cxx index aa60be9..28892cf 100644 --- a/build2/cxx/module.cxx +++ b/build2/cxx/module.cxx @@ -101,6 +101,12 @@ namespace build2 b.assign ("cxx.libs") += cast_null<strings> ( config::optional (r, "config.cxx.libs")); + // Configuration hints for the bin module. They will only be used on the + // first loading of the bin module (for this project) so we only + // populate them on our first loading. + // + variable_map bin_hints; + // config.cxx // if (first) @@ -145,6 +151,65 @@ namespace build2 r.assign<string> ("cxx.signature") = move (ci.signature); r.assign<string> ("cxx.checksum") = move (ci.checksum); + // While we still have the original, compiler-reported target, see if + // we can derive a binutils program pattern. + // + // BTW, for GCC we also get gcc-{ar,ranlib} which add support for the + // LTO plugin though it seems more recent GNU binutils (2.25) are able + // to load the plugin when needed automatically. So it doesn't seem we + // should bother trying to support this on our end (the way we could + // do it is by passing config.bin.{ar,ranlib} as hints). + // + string pattern; + + if (cast<string> (r["cxx.id"]) == "msvc") + { + // If the compiler name is/starts with 'cl' (e.g., cl.exe, cl-14), + // then replace it with '*' and use it as a pattern for lib, link, + // etc. + // + if (cxx.size () > 2) + { + const string& l (cxx.leaf ().string ()); + size_t n (l.size ()); + + if (n >= 2 && + (l[0] == 'c' || l[0] == 'C') && + (l[1] == 'l' || l[1] == 'L') && + (n == 2 || l[2] == '.' || l[2] == '-')) + { + path p (cxx.directory ()); + p /= "*"; + p += l.c_str () + 2; + pattern = move (p).string (); + } + } + } + else + { + // When cross-compiling the whole toolchain is normally prefixed + // with the target triplet, e.g., x86_64-w64-mingw32-{g++,ar,ld}. + // + const string& t (ci.target); + size_t n (t.size ()); + + if (cxx.size () > n + 1) + { + const string& l (cxx.leaf ().string ()); + + if (l.size () > n + 1 && l.compare (0, n, t) == 0 && l[n] == '-') + { + path p (cxx.directory ()); + p /= t; + p += "-*"; + pattern = move (p).string (); + } + } + } + + if (!pattern.empty ()) + bin_hints.assign ("config.bin.pattern") = move (pattern); + // Split/canonicalize the target. // @@ -166,6 +231,11 @@ namespace build2 l5 ([&]{trace << "canonical target: '" << canon << "'; " << "class: " << t.class_;}); + // Pass the target we extracted from the C++ compiler as a config + // hint to the bin module. + // + bin_hints.assign ("config.bin.target") = canon; + // Enter as cxx.target.{cpu,vendor,system,version,class}. // r.assign<string> ("cxx.target") = move (canon); @@ -189,28 +259,19 @@ namespace build2 // Initialize the bin module. Only do this if it hasn't already been // loaded so that we don't overwrite user's bin.* settings. // - const string& target (cast<string> (r["cxx.target"])); - if (!cast_false<bool> (b["bin.loaded"])) - { - // Pass the target we extracted from the C++ compiler as a config hint - // to the bin module. - // - variable_map hints; - hints.assign ("config.bin.target") = target; - - load_module ("bin", r, b, loc, false, hints); - } + load_module ("bin", r, b, loc, false, bin_hints); // Verify bin's target matches ours. // { const string& bt (cast<string> (r["bin.target"])); + const string& ct (cast<string> (r["cxx.target"])); - if (bt != target) + if (bt != ct) fail (loc) << "bin and cxx module target platform mismatch" << info << "bin.target is " << bt << - info << "cxx.target is " << target; + info << "cxx.target is " << ct; } // Register target types. |