jit.h

// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
 
#pragma once
 
#include <deque>
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <tuple>
#include <vector>
 
#include <hilti/rt/filesystem.h>
#include <hilti/rt/library.h>
 
#include <hilti/base/util.h>
#include <hilti/compiler/context.h>
#include <hilti/compiler/detail/cxx/unit.h>
 
namespace reproc {
class process;
}
 
namespace hilti {
 
namespace logging::debug {
inline const DebugStream Jit("jit");
} // namespace logging::debug
 
namespace detail::jit {
class Cxx;
} // namespace detail::jit
 
class CxxCode {
public:
    CxxCode(const hilti::rt::filesystem::path& path) { load(path); }
 
    CxxCode(const std::string& id, std::istream& code) { load(id, code); }
 
    explicit CxxCode(const detail::cxx::Unit& u);
 
    bool save(const hilti::rt::filesystem::path& p) const;
 
    bool save(std::ostream& out) const;
 
    const auto& code() const { return _code; }
 
    auto isLoaded() const { return _code.has_value(); }
 
    const std::string& id() const { return _id; }
 
    std::size_t hash() const { return _hash; }
 
protected:
    bool load(const hilti::rt::filesystem::path& path);
 
    bool load(const std::string& id, std::istream& in);
 
private:
    std::string _id;
    std::optional<std::string> _code;
    std::size_t _hash = 0;
};
 
using hilti::rt::Library;
 
class JIT {
public:
    explicit JIT(const std::shared_ptr<Context>& context, bool dump_code = false);
    ~JIT();
 
    JIT() = delete;
    JIT(const JIT&) = delete;
    JIT(JIT&&) noexcept = delete;
    JIT& operator=(const JIT&) = delete;
    JIT& operator=(JIT&&) noexcept = delete;
 
    void add(CxxCode d);
 
    void add(const hilti::rt::filesystem::path& p);
 
    bool hasInputs() { return _codes.size() || _files.size(); }
 
    Result<std::shared_ptr<const Library>> build();
 
    auto context() const { return _context.lock(); }
 
    auto options() const { return context()->options(); }
 
private:
    // Check if we have a working compiler.
    hilti::Result<Nothing> _checkCompiler();
 
    // Compile C++ to object files.
    hilti::Result<Nothing> _compile();
 
    // Link object files into shared library.
    hilti::Result<std::shared_ptr<const Library>> _link();
 
    // Clean up after compilation.
    void _finish();
 
    std::weak_ptr<Context> _context; // global context for options
    bool _dump_code;                 // save all C++ code for debugging
 
    std::vector<hilti::rt::filesystem::path> _files; // all added source files
    std::vector<CxxCode> _codes;                     // all C++ code units to be compiled
    std::vector<hilti::rt::filesystem::path> _objects;
 
    struct Job {
        ~Job();
 
        std::string cmdline;
        std::unique_ptr<reproc::process> process;
        hilti::rt::filesystem::path output; // path to file capturing process output; file will be deleted by destructor
    };
 
    struct JobRunner {
        JobRunner();
 
        using JobID = uint64_t;
 
        Result<JobID> _scheduleJob(const hilti::rt::filesystem::path& cmd, std::vector<std::string> args);
        Result<Nothing> _spawnJob();
        Result<Nothing> _waitForJobs();
        void _recordUserDiagnostics(JobID jid, const Job& job);
        void finish();
 
        using CmdLine = std::vector<std::string>;
        std::deque<std::tuple<JobID, CmdLine>> jobs_pending;
 
        JobID job_counter = 0;
 
        std::map<JobID, Job> jobs;
    };
 
    JobRunner _runner;
    std::size_t _hash = 0;
};
 
} // namespace hilti