linker.h

// This file if part of the llir-opt project.
// Licensing information can be found in the LICENSE file.
// (C) 2018 Nandor Licker. All rights reserved.
 
#pragma once
 
#include <set>
#include <unordered_map>
#include <string>
 
#include <llvm/Support/WithColor.h>
#include <llvm/LTO/LTO.h>
 
class Prog;
class Func;
class Data;
class Xtor;
class Global;
 
 
 
class Linker {
public:
  class Unit {
  public:
    enum class Kind {
      LLIR,
      BITCODE,
      OBJECT,
      DATA,
    };
 
    Unit(std::unique_ptr<Prog> &&prog);
    Unit(std::unique_ptr<llvm::lto::InputFile> &&bitcode);
 
    struct Object { llvm::StringRef Path; };
    Unit(const Object &object);
 
    struct Data { llvm::StringRef Path; };
    Unit(const Data &data);
 
    Unit(Unit &&);
    ~Unit();
 
    Unit &operator=(Unit &&);
 
  private:
    friend class Linker;
    Kind kind_;
    union S {
      std::unique_ptr<Prog> P;
      std::unique_ptr<llvm::lto::InputFile> B;
      std::string D;
      S() {}
      ~S() {}
    } s_;
  };
 
  using Archive = std::list<Linker::Unit>;
 
  Linker(const llvm::Triple &triple, std::string_view output)
    : triple_(triple)
    , output_(output)
    , lto_(false)
  {
  }
 
  llvm::Error LinkUndefined(const std::string &symbol);
  llvm::Error LinkObject(Unit &&unit);
  llvm::Error LinkGroup(std::list<Linker::Unit> &&units);
 
  using LinkResult = std::pair<std::unique_ptr<Prog>, std::vector<std::string>>;
  llvm::Expected<LinkResult> Link();
 
private:
  llvm::Expected<std::vector<std::unique_ptr<Prog>>> Collect();
  void Resolve(Prog &prog);
  void Resolve(llvm::lto::InputFile &obj);
  void Resolve(const std::string &name);
 
  bool Resolves(Prog &prog);
  bool Resolves(llvm::lto::InputFile &prog);
 
  bool Merge(Prog &dest, Prog &source);
  bool Merge(Prog &dest, Func &func);
  bool Merge(Prog &dest, Data &data);
  bool Merge(Prog &dest, Xtor &xtor);
 
  void InitialiseLTO();
 
  llvm::MCTargetOptions CreateMCTargetOptions();
  llvm::TargetOptions CreateTargetOptions();
  llvm::lto::Config CreateLTOConfig();
  llvm::Expected<std::vector<std::unique_ptr<Prog>>> LTO(
      std::vector<std::unique_ptr<llvm::lto::InputFile>> &&modules
  );
 
private:
  llvm::Triple triple_;
  std::string output_;
  std::vector<Unit> units_;
  std::vector<std::string> files_;
  std::set<std::string> unresolved_;
  std::set<std::string> resolved_;
  std::set<llvm::StringRef> linked_;
  bool lto_;
};