From ea24f530048cbce0c5335ca3fd3632c8ce34315a Mon Sep 17 00:00:00 2001 From: Karen Arutyunov Date: Sat, 24 Aug 2019 16:37:29 +0300 Subject: Move bin build system module to separate library --- libbuild2/bin/target.hxx | 363 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 363 insertions(+) create mode 100644 libbuild2/bin/target.hxx (limited to 'libbuild2/bin/target.hxx') diff --git a/libbuild2/bin/target.hxx b/libbuild2/bin/target.hxx new file mode 100644 index 0000000..3b1708a --- /dev/null +++ b/libbuild2/bin/target.hxx @@ -0,0 +1,363 @@ +// file : libbuild2/bin/target.hxx -*- C++ -*- +// copyright : Copyright (c) 2014-2019 Code Synthesis Ltd +// license : MIT; see accompanying LICENSE file + +#ifndef LIBBUILD2_BIN_TARGET_HXX +#define LIBBUILD2_BIN_TARGET_HXX + +#include +#include + +#include + +#include + +namespace build2 +{ + namespace bin + { + // The obj{} target group. + // + // Common base of all objX{} object files. + // + class LIBBUILD2_BIN_SYMEXPORT objx: public file + { + public: + using file::file; + + public: + static const target_type static_type; + }; + + class LIBBUILD2_BIN_SYMEXPORT obje: public objx + { + public: + using objx::objx; + + public: + static const target_type static_type; + virtual const target_type& dynamic_type () const {return static_type;} + }; + + class LIBBUILD2_BIN_SYMEXPORT obja: public objx + { + public: + using objx::objx; + + public: + static const target_type static_type; + virtual const target_type& dynamic_type () const {return static_type;} + }; + + class LIBBUILD2_BIN_SYMEXPORT objs: public objx + { + public: + using objx::objx; + + public: + static const target_type static_type; + virtual const target_type& dynamic_type () const {return static_type;} + }; + + class LIBBUILD2_BIN_SYMEXPORT obj: public target + { + public: + using target::target; + + public: + static const target_type static_type; + virtual const target_type& dynamic_type () const {return static_type;} + }; + + // Binary module interface (BMI). + // + // While currently there are only C++ modules, if things pan out, chances + // are we will have C (or Obj-C) modules. And in that case it is plausible + // we will also have some binutils to examine BMIs, similar to objdump, + // etc. So that's why this target type is in bin and not cxx. + // + // bmi*{} is similar to obj*{} though the semantics is a bit different: + // the idea is that we should try hard to re-use a single bmiX{} file for + // an entire "build" but if that's not possible (because the compilation + // options are too different), then compile a private version for + // ourselves (the definition of "too different" is, of course, compiler- + // specific). + // + // When we compile a module interface unit, we end up with bmi*{} and + // obj*{}. How that obj*{} is produced is compiler-dependent. While it + // makes sense to decouple the production of the two in order to increase + // parallelism, doing so will further complicate the already hairy + // organization. So, at least for now, we produce the two at the same time + // and make obj*{} an ad hoc member of bmi*{}. + // + // There are also header units for which we define a parallel hbmi*{} + // hierarchy. Note that hbmix{} is-a bmix{} (we think of header BMIs as a + // more specialized kind of BMI) so where you need to distinguish between + // header and module BMIs, you should check for headers first. Note also + // that in case of a header unit there may be no obj*{}. + // + // Common base of all bmiX{} interface files. + // + class LIBBUILD2_BIN_SYMEXPORT bmix: public file + { + public: + using file::file; + + public: + static const target_type static_type; + }; + + // Common base of all hbmiX{} interface files. + // + class LIBBUILD2_BIN_SYMEXPORT hbmix: public bmix + { + public: + using bmix::bmix; + + public: + static const target_type static_type; + }; + + class LIBBUILD2_BIN_SYMEXPORT bmie: public bmix + { + public: + using bmix::bmix; + + public: + static const target_type static_type; + virtual const target_type& dynamic_type () const {return static_type;} + }; + + class LIBBUILD2_BIN_SYMEXPORT hbmie: public hbmix + { + public: + using hbmix::hbmix; + + public: + static const target_type static_type; + virtual const target_type& dynamic_type () const {return static_type;} + }; + + class LIBBUILD2_BIN_SYMEXPORT bmia: public bmix + { + public: + using bmix::bmix; + + public: + static const target_type static_type; + virtual const target_type& dynamic_type () const {return static_type;} + }; + + class LIBBUILD2_BIN_SYMEXPORT hbmia: public hbmix + { + public: + using hbmix::hbmix; + + public: + static const target_type static_type; + virtual const target_type& dynamic_type () const {return static_type;} + }; + + class LIBBUILD2_BIN_SYMEXPORT bmis: public bmix + { + public: + using bmix::bmix; + + public: + static const target_type static_type; + virtual const target_type& dynamic_type () const {return static_type;} + }; + + class LIBBUILD2_BIN_SYMEXPORT hbmis: public hbmix + { + public: + using hbmix::hbmix; + + public: + static const target_type static_type; + virtual const target_type& dynamic_type () const {return static_type;} + }; + + class LIBBUILD2_BIN_SYMEXPORT bmi: public target + { + public: + using target::target; + + public: + static const target_type static_type; + virtual const target_type& dynamic_type () const {return static_type;} + }; + + class LIBBUILD2_BIN_SYMEXPORT hbmi: public target + { + public: + using target::target; + + public: + static const target_type static_type; + virtual const target_type& dynamic_type () const {return static_type;} + }; + + + // Common base for lib{} and libul{} groups. + // + // We use mtime_target as a base for the "trust me it exists" functionality + // which we use, for example, to have installed lib{} prerequisites that + // are matched by the fallback file rule. + // + class LIBBUILD2_BIN_SYMEXPORT libx: public mtime_target + { + public: + using mtime_target::mtime_target; + + public: + static const target_type static_type; + }; + + // The libue{} target, libul{} group and libua{} and libus{} members + // (utility library). + // + // Utility libraries are static libraries that differ based on the kind of + // object files they contains. Note that the libul{} group is more like + // obj{} rather than lib{} in that one does not build the group directly + // rather picking a suitable member. + // + // libul{} is a "library utility library" in that the choice of members is + // libua{} or libus{}, even when linking an executable (normally a unit + // test). + // + // Note that there is no "general utility library" with all three types of + // members (that would cause member uplink ambiguity). If you need to + // build both a library from libua{}/libus{} and an executable from + // libue{} then you will need to arrange this explicitly, for example: + // + // exe{foo}: libue{foo} + // lib{foo}: libul{foo} + // + // {libue libul}{foo}: cxx{*} + // + // Common base of all libuX{} static libraries. + // + class LIBBUILD2_BIN_SYMEXPORT libux: public file + { + public: + using file::file; + + public: + static const target_type static_type; + }; + + class LIBBUILD2_BIN_SYMEXPORT libue: public libux + { + public: + using libux::libux; + + public: + static const target_type static_type; + virtual const target_type& dynamic_type () const {return static_type;} + }; + + class LIBBUILD2_BIN_SYMEXPORT libua: public libux + { + public: + using libux::libux; + + public: + static const target_type static_type; + virtual const target_type& dynamic_type () const {return static_type;} + }; + + class LIBBUILD2_BIN_SYMEXPORT libus: public libux + { + public: + using libux::libux; + + public: + static const target_type static_type; + virtual const target_type& dynamic_type () const {return static_type;} + }; + + class LIBBUILD2_BIN_SYMEXPORT libul: public libx + { + public: + using libx::libx; + + public: + static const target_type static_type; + virtual const target_type& dynamic_type () const {return static_type;} + }; + + // The lib{} target group. + // + class LIBBUILD2_BIN_SYMEXPORT liba: public file + { + public: + using file::file; + + public: + static const target_type static_type; + virtual const target_type& dynamic_type () const {return static_type;} + }; + + class LIBBUILD2_BIN_SYMEXPORT libs: public file + { + public: + using file::file; + + public: + static const target_type static_type; + + virtual const target_type& + dynamic_type () const override {return static_type;} + }; + + // Standard layout type compatible with group_view's const target*[2]. + // + struct lib_members + { + const liba* a = nullptr; + const libs* s = nullptr; + }; + + class LIBBUILD2_BIN_SYMEXPORT lib: public libx, public lib_members + { + public: + using libx::libx; + + virtual group_view + group_members (action) const override; + + public: + static const target_type static_type; + + virtual const target_type& + dynamic_type () const override {return static_type;} + }; + + // Windows import library. + // + class LIBBUILD2_BIN_SYMEXPORT libi: public file + { + public: + using file::file; + + public: + static const target_type static_type; + virtual const target_type& dynamic_type () const {return static_type;} + }; + + // Windows module definition (.def). + // + class LIBBUILD2_BIN_SYMEXPORT def: public file + { + public: + using file::file; + + public: + static const target_type static_type; + virtual const target_type& dynamic_type () const {return static_type;} + }; + } +} + +#endif // LIBBUILD2_BIN_TARGET_HXX -- cgit v1.1