aboutsummaryrefslogtreecommitdiff
path: root/libbuild2/cc
diff options
context:
space:
mode:
Diffstat (limited to 'libbuild2/cc')
-rw-r--r--libbuild2/cc/common.cxx4
-rw-r--r--libbuild2/cc/common.hxx12
-rw-r--r--libbuild2/cc/compile-rule.cxx97
-rw-r--r--libbuild2/cc/compile-rule.hxx2
-rw-r--r--libbuild2/cc/link-rule.cxx176
-rw-r--r--libbuild2/cc/link-rule.hxx8
-rw-r--r--libbuild2/cc/pkgconfig.cxx2
7 files changed, 238 insertions, 63 deletions
diff --git a/libbuild2/cc/common.cxx b/libbuild2/cc/common.cxx
index 62f0ee0..9cac1b0 100644
--- a/libbuild2/cc/common.cxx
+++ b/libbuild2/cc/common.cxx
@@ -721,7 +721,7 @@ namespace build2
}
// Look for binary-less libraries via pkg-config .pc files. Note that
- // it is possible we have already found one of them as binfull but the
+ // it is possible we have already found one of them as binful but the
// other is binless.
//
{
@@ -731,7 +731,7 @@ namespace build2
if (na || ns)
{
// Only consider the common .pc file if we can be sure there
- // is no binfull variant.
+ // is no binful variant.
//
pair<path, path> r (
pkgconfig_search (d, p.proj, name, na && ns /* common */));
diff --git a/libbuild2/cc/common.hxx b/libbuild2/cc/common.hxx
index bf971ab..f072591 100644
--- a/libbuild2/cc/common.hxx
+++ b/libbuild2/cc/common.hxx
@@ -42,6 +42,18 @@ namespace build2
//
const char* const* x_hinters;
+ // We set this variable on the bmi*{} target to indicate whether it
+ // belongs to a binless library. More specifically, it controls both
+ // the production and consumption (linking) of the object file with
+ // the following possible states:
+ //
+ // produce consume
+ // true y y (binless normal or sidebuild)
+ // false n n (binful sidebuild)
+ // absent y n (binful normal)
+ //
+ const variable& b_binless; // bin.binless
+
const variable& config_x;
const variable& config_x_id; // <type>[-<variant>]
const variable& config_x_version;
diff --git a/libbuild2/cc/compile-rule.cxx b/libbuild2/cc/compile-rule.cxx
index 7cea9d6..a02b3c4 100644
--- a/libbuild2/cc/compile-rule.cxx
+++ b/libbuild2/cc/compile-rule.cxx
@@ -704,12 +704,16 @@ namespace build2
}
}
- // If we are compiling a BMI-producing module TU, then the obj*{} is
- // an ad hoc member of bmi*{}. For now neither GCC nor Clang produce
- // an object file for a header unit (but something tells me this is
- // going to change).
+ // If we are compiling a BMI-producing module TU, then add obj*{} an
+ // ad hoc member of bmi*{} unless we only need the BMI (see
+ // config_data::b_binless for details).
//
- if (ut == unit_type::module_intf) // Note: still unrefined.
+ // For now neither GCC nor Clang produce an object file for a header
+ // unit (but something tells me this might change).
+ //
+ // Note: ut is still unrefined.
+ //
+ if (ut == unit_type::module_intf && cast_true<bool> (t[b_binless]))
{
// The module interface unit can be the same as an implementation
// (e.g., foo.mxx and foo.cxx) which means obj*{} targets could
@@ -5404,8 +5408,8 @@ namespace build2
// implicit import, if you will). Do you see where it's going? Nowever
// good, that's right. This shallow reference means that the compiler
// should be able to find BMIs for all the re-exported modules,
- // recursive. The good news is we are actually in a pretty good shape to
- // handle this: after match all our prerequisite BMIs will have their
+ // recursively. The good news is we are actually in a pretty good shape
+ // to handle this: after match all our prerequisite BMIs will have their
// prerequisite BMIs known, recursively. The only bit that is missing is
// the re-export flag of some sorts. As well as deciding where to handle
// it: here or in append_module_options(). After some meditation it
@@ -5423,6 +5427,8 @@ namespace build2
// bmi{}s have been matched by the same rule. But let's not kid
// ourselves, there will be no other rule that matches bmi{}s.
//
+ // @@ I think now we could use prerequisite_targets::data for this?
+ //
// 2. Once we have matched all the bmi{}s we are importing directly
// (with all the re-exported by us at the back), we will go over them
// and copy all of their re-exported bmi{}s (using the position we
@@ -5553,12 +5559,12 @@ namespace build2
if (pt != nullptr)
{
- const target* lt (nullptr);
+ const file* lt (nullptr);
if (const libx* l = pt->is_a<libx> ())
lt = link_member (*l, a, li);
else if (pt->is_a<liba> () || pt->is_a<libs> () || pt->is_a<libux> ())
- lt = pt;
+ lt = &pt->as<file> ();
// If this is a library, check its bmi{}s and mxx{}s.
//
@@ -5951,7 +5957,7 @@ namespace build2
const file& compile_rule::
make_module_sidebuild (action a,
const scope& bs,
- const target& lt,
+ const file& lt,
const target& mt,
const string& mn) const
{
@@ -5965,17 +5971,16 @@ namespace build2
// not to conflict with other modules. If we assume that within an
// amalgamation there is only one "version" of each module, then the
// module name itself seems like a good fit. We just replace '.' with
- // '-'.
+ // '-' and ':' with '+'.
//
string mf;
transform (mn.begin (), mn.end (),
back_inserter (mf),
- [] (char c) {return c == '.' ? '-' : c;});
+ [] (char c) {return c == '.' ? '-' : c == ':' ? '+' : c;});
// It seems natural to build a BMI type that corresponds to the library
// type. After all, this is where the object file part of the BMI is
- // going to come from (though things will probably be different for
- // module-only libraries).
+ // going to come from (unless it's a module interface-only library).
//
const target_type& tt (compile_types (link_type (lt).type).bmi);
@@ -6012,6 +6017,10 @@ namespace build2
// @@ TODO: will probably need revision if using sidebuild for
// non-installed libraries (e.g., direct BMI dependencies
// will probably have to be translated to mxx{} or some such).
+ // Hm, don't think we want it this way: we want BMIs of binless
+ // library to be built in the library rather than on the side
+ // (so they can be potentially re-used by multiple independent
+ // importers).
//
if (p.is_a<libx> () ||
p.is_a<liba> () || p.is_a<libs> () || p.is_a<libux> ())
@@ -6034,8 +6043,15 @@ namespace build2
// while we were preparing the prerequisite list.
//
if (p.second.owns_lock ())
+ {
bt.prerequisites (move (ps));
+ // Unless this is a binless library, we don't need the object file
+ // (see config_data::b_binless for details).
+ //
+ bt.vars.assign (b_binless) = (lt.mtime () == timestamp_unreal);
+ }
+
return bt;
}
@@ -6410,17 +6426,28 @@ namespace build2
cstrings args {cpath.recall_string ()};
// If we are building a module interface or partition, then the target
- // is bmi*{} and its ad hoc member is obj*{}. For header units there is
- // no obj*{}.
+ // is bmi*{} and it may have an ad hoc obj*{} member. For header units
+ // there is no obj*{} (see the corresponding add_adhoc_member() call in
+ // apply()).
//
path relm;
- path relo (ut == unit_type::module_header
- ? path ()
- : relative (ut == unit_type::module_intf ||
- ut == unit_type::module_intf_part ||
- ut == unit_type::module_impl_part
- ? find_adhoc_member<file> (t, tts.obj)->path ()
- : tp));
+ path relo;
+ switch (ut)
+ {
+ case unit_type::module_header:
+ break;
+ case unit_type::module_intf:
+ case unit_type::module_intf_part:
+ case unit_type::module_impl_part:
+ {
+ if (const file* o = find_adhoc_member<file> (t, tts.obj))
+ relo = relative (o->path ());
+
+ break;
+ }
+ default:
+ relo = relative (tp);
+ }
// Build the command line.
//
@@ -6526,6 +6553,8 @@ namespace build2
// Note also that what we are doing here appears to be incompatible
// with PCH (/Y* options) and /Gm (minimal rebuild).
//
+ // @@ MOD: TODO deal with absent relo.
+ //
if (find_options ({"/Zi", "/ZI"}, args))
{
if (fc)
@@ -6699,16 +6728,34 @@ namespace build2
// Output module file is specified in the mapping file, the
// same as input.
//
- if (ut != unit_type::module_header) // No object file.
+ if (ut == unit_type::module_header) // No obj, -c implied.
+ break;
+
+ if (!relo.empty ())
{
args.push_back ("-o");
args.push_back (relo.string ().c_str ());
- args.push_back ("-c");
}
+ else if (ut != unit_type::module_header)
+ {
+ // Should this be specified in append_lang_options() like
+ // -fmodule-header (which, BTW, implies -fmodule-only)?
+ // While it's plausible that -fmodule-header has some
+ // semantic differences that should be in effect during
+ // preprocessing, -fmodule-only seems to only mean "don't
+ // write the object file" so for now we specify it only
+ // here.
+ //
+ args.push_back ("-fmodule-only");
+ }
+
+ args.push_back ("-c");
break;
}
case compiler_type::clang:
{
+ // @@ MOD TODO: deal with absent relo.
+
relm = relative (tp);
args.push_back ("-o");
diff --git a/libbuild2/cc/compile-rule.hxx b/libbuild2/cc/compile-rule.hxx
index 2d80d18..a716b4c 100644
--- a/libbuild2/cc/compile-rule.hxx
+++ b/libbuild2/cc/compile-rule.hxx
@@ -166,7 +166,7 @@ namespace build2
find_modules_sidebuild (const scope&) const;
const file&
- make_module_sidebuild (action, const scope&, const target&,
+ make_module_sidebuild (action, const scope&, const file&,
const target&, const string&) const;
const file&
diff --git a/libbuild2/cc/link-rule.cxx b/libbuild2/cc/link-rule.cxx
index dea5879..3f6824e 100644
--- a/libbuild2/cc/link-rule.cxx
+++ b/libbuild2/cc/link-rule.cxx
@@ -583,37 +583,37 @@ namespace build2
move (cp_l), move (cp_v)};
}
- // Look for binary-full utility library recursively until we hit a
- // non-utility "barier".
+ // Look for binful utility library recursively until we hit a non-utility
+ // "barier".
//
- static bool
- find_binfull (action a, const target& t, linfo li)
+ static const libux*
+ find_binful (action a, const target& t, linfo li)
{
for (const target* pt: t.prerequisite_targets[a])
{
if (pt == nullptr || unmark (pt) != 0) // Called after pass 1 below.
continue;
- const file* pf;
+ const libux* ux;
// If this is the libu*{} group, then pick the appropriate member.
//
if (const libul* ul = pt->is_a<libul> ())
{
- pf = &link_member (*ul, a, li)->as<file> ();
+ ux = &link_member (*ul, a, li)->as<libux> ();
}
- else if ((pf = pt->is_a<libue> ()) ||
- (pf = pt->is_a<libus> ()) ||
- (pf = pt->is_a<libua> ()))
+ else if ((ux = pt->is_a<libue> ()) ||
+ (ux = pt->is_a<libus> ()) ||
+ (ux = pt->is_a<libua> ()))
;
else
continue;
- if (!pf->path ().empty () || find_binfull (a, *pf, li))
- return true;
+ if (!ux->path ().empty () || (ux = find_binful (a, *ux, li)))
+ return ux;
}
- return false;
+ return nullptr;
};
recipe link_rule::
@@ -642,6 +642,7 @@ namespace build2
t.state[a].assign (c_type) = string (x);
bool binless (lt.library ()); // Binary-less until proven otherwise.
+ bool user_binless (lt.library () && cast_false<bool> (t[b_binless]));
// Inject dependency on the output directory. Note that we do it even
// for binless libraries since there could be other output (e.g., .pc
@@ -655,7 +656,7 @@ namespace build2
//
// Also clear the binless flag if we see any source or object files.
// Note that if we don't see any this still doesn't mean the library is
- // binless since it can depend on a binfull utility library. This we
+ // binless since it can depend on a binful utility library. This we
// check below, after matching the libraries.
//
// We do libraries first in order to indicate that we will execute these
@@ -680,9 +681,9 @@ namespace build2
optional<dir_paths> usr_lib_dirs; // Extract lazily.
compile_target_types tts (compile_types (ot));
- auto skip = [&a, &rs] (const target* pt) -> bool
+ auto skip = [&a, &rs] (const target& pt) -> bool
{
- return a.operation () == clean_id && !pt->dir.sub (rs.out_path ());
+ return a.operation () == clean_id && !pt.dir.sub (rs.out_path ());
};
auto& pts (t.prerequisite_targets[a]);
@@ -713,15 +714,13 @@ namespace build2
if (mod || p.is_a (x_src) || p.is_a<c> ())
{
- binless = binless && false;
+ binless = binless && (mod ? user_binless : false);
// Rule chaining, part 1.
//
-
// Which scope shall we use to resolve the root? Unlikely, but
// possible, the prerequisite is from a different project
// altogether. So we are going to use the target's project.
- //
// If the source came from the lib{} group, then create the obj{}
// group and add the source as a prerequisite of the obj{} group,
@@ -763,19 +762,44 @@ namespace build2
// obj/bmi{} is always in the out tree. Note that currently it could
// be the group -- we will pick a member in part 2 below.
//
- pt = &search (t, rtt, d, dir_path (), *cp.tk.name, nullptr, cp.scope);
+ pair<target&, ulock> r (
+ search_locked (
+ t, rtt, d, dir_path (), *cp.tk.name, nullptr, cp.scope));
// If we shouldn't clean obj{}, then it is fair to assume we
// shouldn't clean the source either (generated source will be in
// the same directory as obj{} and if not, well, go find yourself
// another build system ;-)).
//
- if (skip (pt))
+ if (skip (r.first))
{
pt = nullptr;
continue;
}
+ // Either set of verify the bin.binless value on this bmi*{} target
+ // (see config_data::b_binless for semantics).
+ //
+ if (mod)
+ {
+ if (r.second.owns_lock ())
+ {
+ if (user_binless)
+ r.first.assign (b_binless) = true;
+ }
+ else
+ {
+ lookup l (r.first[b_binless]);
+
+ if (user_binless ? !cast_false<bool> (l) : l.defined ())
+ fail << "synthesized dependency for prerequisite " << p
+ << " would be incompatible with existing target "
+ << r.first <<
+ info << "incompatible bin.binless value";
+ }
+ }
+
+ pt = &r.first;
m = mod ? 2 : 1;
}
else if (p.is_a<libx> () ||
@@ -797,7 +821,7 @@ namespace build2
if (pt == nullptr)
pt = &p.search (t);
- if (skip (pt))
+ if (skip (*pt))
m = 3; // Mark so it is not matched.
// If this is the lib{}/libu{} group, then pick the appropriate
@@ -844,19 +868,28 @@ namespace build2
pt = &p.search (t);
}
- if (skip (pt))
+ if (skip (*pt))
{
pt = nullptr;
continue;
}
- // @@ MODHDR: hbmix{} has no objx{}
+ // Header BMIs have no object file. Module BMI must be explicitly
+ // marked with bin.binless by the user to be usable in a binless
+ // library.
//
- binless = binless && !(pt->is_a<objx> () || pt->is_a<bmix> ());
+ binless = binless && !(
+ pt->is_a<objx> () ||
+ (pt->is_a<bmix> () &&
+ !pt->is_a<hbmix> () &&
+ cast_false<bool> ((*pt)[b_binless])));
m = 3;
}
+ if (user_binless && !binless)
+ fail << t << " cannot be binless due to " << p << " prerequisite";
+
mark (pt, m);
}
@@ -864,9 +897,19 @@ namespace build2
//
match_members (a, t, pts, start);
- // Check if we have any binfull utility libraries.
+ // Check if we have any binful utility libraries.
//
- binless = binless && !find_binfull (a, t, li);
+ if (binless)
+ {
+ if (const libux* l = find_binful (a, t, li))
+ {
+ binless = false;
+
+ if (user_binless)
+ fail << t << " cannot be binless due to binful " << *l
+ << " prerequisite";
+ }
+ }
// Now that we know for sure whether we are binless, derive file name(s)
// and add ad hoc group members. Note that for binless we still need the
@@ -1176,10 +1219,11 @@ namespace build2
? (group ? bmi::static_type : tts.bmi)
: (group ? obj::static_type : tts.obj));
- // If this obj*{} already has prerequisites, then verify they are
- // "compatible" with what we are doing here. Otherwise, synthesize
- // the dependency. Note that we may also end up synthesizing with
- // someone beating us to it. In this case also verify.
+ // If this obj*/bmi*{} already has prerequisites, then verify they
+ // are "compatible" with what we are doing here. Otherwise,
+ // synthesize the dependency. Note that we may also end up
+ // synthesizing with someone beating us to it. In this case also
+ // verify.
//
bool verify (true);
@@ -1397,7 +1441,7 @@ namespace build2
// If this is a library not to be cleaned, we can finally blank it
// out.
//
- if (skip (pt))
+ if (skip (*pt))
{
pt = nullptr;
continue;
@@ -2003,6 +2047,50 @@ namespace build2
}
}
+ // Append object files of bmi{} prerequisites that belong to binless
+ // libraries.
+ //
+ void link_rule::
+ append_binless_modules (strings& args,
+ const scope& bs, action a, const file& t) const
+ {
+ // Note that here we don't need to hoist anything on duplicate detection
+ // since the order in which we link object files is not important.
+ //
+ for (const target* pt: t.prerequisite_targets[a])
+ {
+ if (pt != nullptr &&
+ pt->is_a<bmix> () &&
+ cast_false<bool> ((*pt)[b_binless]))
+ {
+ const objx& o (*find_adhoc_member<objx> (*pt)); // Must be there.
+ string p (relative (o.path ()).string ());
+ if (find (args.begin (), args.end (), p) == args.end ())
+ {
+ args.push_back (move (p));
+ append_binless_modules (args, bs, a, o);
+ }
+ }
+ }
+ }
+
+ void link_rule::
+ append_binless_modules (sha256& cs,
+ const scope& bs, action a, const file& t) const
+ {
+ for (const target* pt: t.prerequisite_targets[a])
+ {
+ if (pt != nullptr &&
+ pt->is_a<bmix> () &&
+ cast_false<bool> ((*pt)[b_binless]))
+ {
+ const objx& o (*find_adhoc_member<objx> (*pt));
+ hash_path (cs, o.path (), bs.root_scope ()->out_path ());
+ append_binless_modules (cs, bs, a, o);
+ }
+ }
+ }
+
// Filter link.exe noise (msvc.cxx).
//
void
@@ -2635,8 +2723,13 @@ namespace build2
//
if (modules)
{
- if (pt->is_a<bmix> ()) // @@ MODHDR: hbmix{} has no objx{}
+ if (pt->is_a<bmix> ())
+ {
pt = find_adhoc_member (*pt, tts.obj);
+
+ if (pt == nullptr) // Header BMIs have no object file.
+ continue;
+ }
}
const file* f;
@@ -2669,7 +2762,12 @@ namespace build2
f = nullptr; // Timestamp checked by hash_libraries().
}
else
+ {
hash_path (cs, f->path (), rs.out_path ());
+
+ if (modules)
+ append_binless_modules (cs, rs, a, *f);
+ }
}
else if ((f = pt->is_a<bin::def> ()))
{
@@ -2963,8 +3061,13 @@ namespace build2
if (modules)
{
- if (pt->is_a<bmix> ()) // @@ MODHDR: hbmix{} has no objx{}
+ if (pt->is_a<bmix> ())
+ {
pt = find_adhoc_member (*pt, tts.obj);
+
+ if (pt == nullptr) // Header BMIs have no object file.
+ continue;
+ }
}
const file* f;
@@ -2985,7 +3088,12 @@ namespace build2
// files might satisfy symbols in the preceding libraries.
//
als.clear ();
- sargs.push_back (relative (f->path ()).string ()); // string()&&
+
+ sargs.push_back (relative (f->path ()).string ());
+
+ if (modules)
+ append_binless_modules (sargs, bs, a, *f);
+
seen_obj = true;
}
}
diff --git a/libbuild2/cc/link-rule.hxx b/libbuild2/cc/link-rule.hxx
index 6d0649c..baccf8d 100644
--- a/libbuild2/cc/link-rule.hxx
+++ b/libbuild2/cc/link-rule.hxx
@@ -131,6 +131,14 @@ namespace build2
const scope&, action,
const target&, linfo, bool) const;
+ void
+ append_binless_modules (strings&,
+ const scope&, action, const file&) const;
+
+ void
+ append_binless_modules (sha256&,
+ const scope&, action, const file&) const;
+
protected:
static void
functions (function_family&, const char*); // functions.cxx
diff --git a/libbuild2/cc/pkgconfig.cxx b/libbuild2/cc/pkgconfig.cxx
index f0a5e0c..6c0f1fc 100644
--- a/libbuild2/cc/pkgconfig.cxx
+++ b/libbuild2/cc/pkgconfig.cxx
@@ -1524,7 +1524,7 @@ namespace build2
os << "Libs:";
// While we don't need it for a binless library itselt, it may be
- // necessary to resolve its binfull dependencies.
+ // necessary to resolve its binful dependencies.
//
os << " -L" << escape (ldir.string ());