driver.h

// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
// p
 
#pragma once
 
#include <fstream>
#include <iostream>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <string_view>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
 
#include <hilti/rt/filesystem.h>
 
#include <hilti/base/logger.h>
#include <hilti/base/result.h>
#include <hilti/base/timing.h>
#include <hilti/compiler/context.h>
#include <hilti/compiler/unit.h>
 
namespace hilti {
 
class JIT;
struct Options;
 
namespace driver {
 
enum class Dependencies {
    None, 
    All,  
    Code  
};
 
struct Options {
    bool include_linker = false;    
    bool output_hilti = false;      
    bool output_prototypes = false; 
    bool output_cxx = false;        
    std::string output_cxx_prefix;  
    bool output_linker = false;     
    Dependencies output_dependencies = Dependencies::None; 
    bool execute_code = false;                             
    bool show_backtraces = false;                          
    bool abort_on_exceptions = false;                      
    bool keep_tmps = false;                                
    bool skip_dependencies = false;                        
    bool report_resource_usage = false; 
    bool report_times = false;          
    bool dump_code = false;             
    bool enable_profiling = false;      
    std::vector<hilti::rt::filesystem::path>
        inputs; 
    hilti::rt::filesystem::path output_path; 
    std::unique_ptr<Logger>
        logger; 
    Options() { logger = std::make_unique<Logger>(); }
};
 
} // namespace driver
 
class Driver {
public:
    explicit Driver(std::string name);
 
    Driver(std::string name, const hilti::rt::filesystem::path& argv0);
 
    virtual ~Driver();
 
    Driver() = delete;
    Driver(const Driver&) = delete;
    Driver(Driver&&) noexcept = delete;
    Driver& operator=(const Driver&) = delete;
    Driver& operator=(Driver&&) noexcept = delete;
 
    Result<Nothing> parseOptions(int argc, char** argv);
 
    void registerUnit(const std::shared_ptr<Unit>& unit) { _addUnit(unit); }
 
    Unit* lookupUnit(const declaration::module::UID& uid) const {
        auto i = _units.find(uid);
        return i != _units.end() ? i->second.get() : nullptr;
    }
 
    void updateProcessExtension(const declaration::module::UID& uid, const hilti::rt::filesystem::path& ext);
 
    Result<Nothing> addInput(const hilti::rt::filesystem::path& path);
 
    Result<Nothing> addInput(declaration::module::UID uid);
 
    bool hasInputs() const { return ! (_units.empty() && _libraries.empty() && _external_cxxs.empty()); }
 
    const auto& driverOptions() const { return _driver_options; }
 
    const auto& hiltiOptions() const { return _compiler_options; }
 
    void setDriverOptions(driver::Options options);
 
    void setCompilerOptions(hilti::Options options);
 
    Result<Nothing> initialize();
 
    Result<Nothing> compile();
 
    const auto& context() const { return _ctx; }
 
    auto* builder() const { return _builder.get(); }
 
    const auto& options() const { return _ctx->options(); }
 
    Result<Nothing> initRuntime();
 
    Result<Nothing> executeMain();
 
    Result<Nothing> finishRuntime();
 
    void fatalError(const std::string& msg);
 
    void fatalError(const hilti::result::Error& error);
 
    Result<Nothing> run();
 
protected:
    friend class ASTContext;
 
    void usage();
 
    Result<Nothing> compileUnits();
 
    Result<Nothing> codegenUnits();
 
    Result<Nothing> linkUnits();
 
    Result<Nothing> outputUnits();
 
    Result<Nothing> jitUnits();
 
    result::Error error(std::string_view msg, const hilti::rt::filesystem::path& p = "");
 
    result::Error augmentError(const result::Error& err, const hilti::rt::filesystem::path& p = "");
 
    Result<std::unique_ptr<std::ostream>> openOutput(const hilti::rt::filesystem::path& p,
                                                     bool binary = false,
                                                     bool append = false);
 
    Result<Nothing> openInput(std::ifstream& in, const hilti::rt::filesystem::path& p);
 
    Result<Nothing> writeOutput(std::ifstream& in, const hilti::rt::filesystem::path& p);
 
    Result<std::stringstream> readInput(const hilti::rt::filesystem::path& p);
 
    void dumpUnit(const Unit& unit);
 
    void printHiltiException(const hilti::rt::Exception& e);
 
    virtual std::unique_ptr<Builder> createBuilder(ASTContext* ctx) const;
 
    virtual std::string hookAddCommandLineOptions() { return ""; }
 
    virtual bool hookProcessCommandLineOption(int /*opt*/, const char* /*optarg*/) { return false; }
 
    virtual std::string hookAugmentUsage() { return ""; }
 
    virtual void hookAddInput(std::shared_ptr<Unit> unit) {} // NOLINT(performance-unnecessary-value-param)
 
    virtual void hookAddInput(const hilti::rt::filesystem::path& path) {}
 
    virtual void hookNewASTPreCompilation(const Plugin& plugin, ASTRoot* root) {}
 
    virtual bool hookNewASTPostCompilation(const Plugin& /*plugin*/, ASTRoot* /*root*/) { return false; }
 
    virtual Result<Nothing> hookCompilationFinished(ASTRoot* /*root*/) { return Nothing(); }
 
    virtual void hookInitRuntime() {}
 
    virtual void hookFinishRuntime() {}
 
private:
    // Tracking the state of the compilation pipeline to catch out of order
    // operation.
    enum Stage { UNINITIALIZED, INITIALIZED, COMPILED, CODEGENED, LINKED, JITTED } _stage = UNINITIALIZED;
 
    // Backend for adding a new unit.
    void _addUnit(const std::shared_ptr<Unit>& unit);
 
    // Run a specific plugin's AST passes on all units with the corresponding extension.
    Result<Nothing> _resolveUnitsWithPlugin(const Plugin& plugin, std::vector<std::shared_ptr<Unit>> units, int& round);
 
    // Runs a specific plugin's transform step on a given set of units.
    Result<Nothing> _transformUnitsWithPlugin(const Plugin& plugin, const std::vector<std::shared_ptr<Unit>>& units);
 
    // Run all plugins on current units, iterating until finished.
    Result<Nothing> _resolveUnits();
 
    // Turns all HILTI units into C++.
    Result<Nothing> _codegenUnits();
 
    // Performs global transformations on the generated code.
    Result<Nothing> _optimizeUnits();
 
    // Sends a debug dump of a unit's AST to the global logger.
    void _dumpAST(const std::shared_ptr<Unit>& unit,
                  const logging::DebugStream& stream,
                  const Plugin& plugin,
                  const std::string& prefix,
                  int round);
 
    // Sends a debug dump of a unit's AST to the global logger.
    void _dumpAST(const std::shared_ptr<Unit>& unit, const logging::DebugStream& stream, const std::string& prefix);
 
    // Sends a debug dump of a unit's AST to an output stream.
    void _dumpAST(const std::shared_ptr<Unit>& unit,
                  std::ostream& stream,
                  const Plugin& plugin,
                  const std::string& prefix,
                  int round);
 
    // Records a reduced debug dump of a unit's AST limited to just declarations.
    void _dumpDeclarations(const std::shared_ptr<Unit>& unit, const Plugin& plugin);
 
    // Records a debug dump of a unit's AST to disk.
    void _saveIterationAST(const std::shared_ptr<Unit>& unit,
                           const Plugin& plugin,
                           const std::string& prefix,
                           int round);
 
    // Records a debug dump of a unit's AST to disk.
    void _saveIterationAST(const std::shared_ptr<Unit>& unit,
                           const Plugin& plugin,
                           const std::string& prefix,
                           const std::string& tag);
 
    // Sets the C++ namespaces for generated code from -x/-P prefix options.
    Result<Nothing> _setCxxNamespacesFromPrefix(const char* prefix);
 
    Result<void*> _symbol(const std::string& symbol);
 
    std::string _name;
    driver::Options _driver_options;
    hilti::Options _compiler_options;
 
    std::shared_ptr<Context> _ctx;                      // driver's compiler context
    std::unique_ptr<hilti::Builder> _builder;           // driver builder tied to its context
    std::unique_ptr<hilti::JIT> _jit;                   // driver's JIT instance
    std::shared_ptr<const hilti::rt::Library> _library; // Compiled code
 
    std::map<declaration::module::UID, std::shared_ptr<Unit>> _units;
    std::vector<CxxCode> _generated_cxxs;
    std::unordered_map<std::string, Library> _libraries;
    std::vector<hilti::rt::filesystem::path> _external_cxxs;
    std::vector<linker::MetaData> _mds;
 
    std::unordered_set<std::string> _processed_paths;
 
    bool _runtime_initialized = false; // true once initRuntime() has succeeded
    std::set<std::string> _tmp_files;  // all tmp files created, so that we can clean them up.
};
 
} // namespace hilti