diff options
Diffstat (limited to 'build/cxx')
| -rw-r--r-- | build/cxx/compile.cxx | 43 | ||||
| -rw-r--r-- | build/cxx/link.cxx | 64 |
2 files changed, 56 insertions, 51 deletions
diff --git a/build/cxx/compile.cxx b/build/cxx/compile.cxx index 48d2240..8dcad1e 100644 --- a/build/cxx/compile.cxx +++ b/build/cxx/compile.cxx @@ -98,46 +98,23 @@ namespace build // A dependency on a library is there so that we can get its // cxx.export.poptions. In particular, making sure it is // executed before us will only restrict parallelism. But we - // do need to match it in order to get its prerequisite_targets - // populated; see append_lib_options() above. + // do need to pre-match it in order to get its + // prerequisite_targets populated. This is the "library + // meta-information protocol". See also append_lib_options() + // above. // if (p.is_a<lib> () || p.is_a<liba> () || p.is_a<libso> ()) { if (a.operation () == update_id) { - // Handle imported libraries. + // Handle imported libraries. We know that for such libraries + // we don't need to do match() in order to get options (if + // any, they would be set by search_library()). // - if (p.proj () != nullptr) + if (p.proj () == nullptr || + link::search_library (lib_paths, p.prerequisite) == nullptr) { - // We know that for such libraries we don't need to do - // match() in order to get options (if any, they would - // be set by search_library()). - // - // @@ What if this is an installed import with an export - // stub? How will such a stub capture prerequsite libs? - // Probably as imported prerequisites, e.g., %lib{z}, not - // as -lz in .libs variable. - // - // In fact, even if we tried match() on lib{}, nothing - // would have matched since that lib{} is out of any - // project and is not a file (which is the case for - // liba/libso). So probably the importing code would - // have to take care of importing all the prerequisite - // libraries. It does make sense since we don't really - // want to match a rule to an installed library. - // - if (link::search_library (lib_paths, p.prerequisite) != nullptr) - continue; - } - - target& pt (p.search ()); - - if (p.is_a<lib> ()) //@@ TMP - build::match_only (a, pt); - else - { - build::match (a, pt); - pt.dependents--; + match_only (a, p.search ()); } } diff --git a/build/cxx/link.cxx b/build/cxx/link.cxx index 5c3a515..97c9696 100644 --- a/build/cxx/link.cxx +++ b/build/cxx/link.cxx @@ -365,7 +365,7 @@ namespace build // (i.e., a utility library). // - bool so (t.is_a<libso> ()); + type lt (link_type (t)); // Scan prerequisites and see if we can work with what we've got. // @@ -384,7 +384,7 @@ namespace build } else if (p.is_a<obja> ()) { - if (so) + if (lt == type::so) fail << "shared library " << t << " prerequisite " << p << " is static object"; @@ -423,6 +423,45 @@ namespace build return nullptr; } + // If we have any prerequisite libraries (which also means that + // we match), search/import and pre-match them to implement the + // "library meta-information protocol". + // + if (seen_lib && lt != type::e) + { + if (t.group != nullptr) + t.group->prerequisite_targets.clear (); // lib{}'s + + search_paths_cache lib_paths; // Extract lazily. + + for (prerequisite_member p: group_prerequisite_members (a, t)) + { + if (p.is_a<lib> () || p.is_a<liba> () || p.is_a<libso> ()) + { + target* pt (nullptr); + + // Handle imported libraries. + // + if (p.proj () != nullptr) + pt = search_library (lib_paths, p.prerequisite); + + if (pt == nullptr) + { + pt = &p.search (); + match_only (a, *pt); + } + + // If the prerequisite came from the lib{} group, then also + // add it to lib's prerequisite_targets. + // + if (!p.prerequisite.belongs (t)) + t.group->prerequisite_targets.push_back (pt); + + t.prerequisite_targets.push_back (pt); + } + } + } + return seen_cxx || seen_c || seen_obj || seen_lib ? &t : nullptr; } @@ -449,6 +488,8 @@ namespace build } } + t.prerequisite_targets.clear (); // See lib pre-match in match() above. + // Inject dependency on the output directory. // inject_parent_fsdir (a, t); @@ -480,27 +521,14 @@ namespace build if (!p.is_a<c> () && !p.is_a<cxx> ()) { - // Handle imported libraries. Essentially, we want to replicate - // the -lfoo functionality but as part of our import support. + // Handle imported libraries. // - if (p.proj () != nullptr && - (p.is_a<lib> () || p.is_a<liba> () || p.is_a<libso> ())) - { + if (p.proj () != nullptr) pt = search_library (lib_paths, p.prerequisite); - // We only need this target if we are updating (remember, like - // -lfoo). The question is why search in the first place? The - // reason is the "not found" situation, in which someone else - // (i.e., the import phase 2) could resolve it to something - // that, who knows, might need cleaning, for example. - // - if (pt != nullptr && a.operation () != update_id) - continue; // Skip. - } - // The rest is the same basic logic as in search_and_match(). // - if (pt == nullptr) // Could've been resolved by search_library(). + if (pt == nullptr) pt = &p.search (); if (a.operation () == clean_id && !pt->dir.sub (*amlg)) |