bitcode.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 <tuple>
#include <vector>
 
#include <llvm/Support/raw_ostream.h>
#include <llvm/Support/MemoryBuffer.h>
 
#include "core/util.h"
#include "core/inst.h"
 
class Block;
class Data;
class Expr;
class Extern;
class Func;
class Global;
class Inst;
class PhiInst;
class Prog;
class Value;
class Object;
class Atom;
class Annot;
class AnnotSet;
class Xtor;
 
 
class BitcodeReader final {
public:
  BitcodeReader(llvm::StringRef buf) : buf_(buf), offset_(0) {}
 
  std::unique_ptr<Prog> Read();
 
private:
  void Read(Func &func);
  void Read(Atom &atom);
  void Read(Extern &ext);
 
  template<typename T> T ReadData();
  template<typename T> std::optional<T> ReadOptional();
  std::string ReadString();
  Inst *ReadInst(
      const std::vector<Ref<Inst>> &map,
      std::vector<std::tuple<PhiInst *, Block *, unsigned>> &fixups
  );
  Expr *ReadExpr();
  Ref<Value> ReadValue(const std::vector<Ref<Inst>> &map);
  Block *ReadBlock(const std::vector<Ref<Inst>> &map);
  Ref<Inst> ReadInst(const std::vector<Ref<Inst>> &map);
  Ref<Constant> ReadConst();
  void ReadAnnot(AnnotSet &annots);
  Xtor *ReadXtor();
  Type ReadType();
  TypeFlag ReadTypeFlag();
  FlaggedType ReadFlaggedType();
 
private:
  llvm::StringRef buf_;
  uint64_t offset_;
  std::vector<Global *> globals_;
};
 
 
class BitcodeWriter final {
public:
  BitcodeWriter(llvm::raw_pwrite_stream &os) : os_(os) {}
 
  void Write(const Prog &prog);
 
private:
  void Write(const Func &prog);
  void Write(const Atom &atom);
  void Write(const Extern &ext);
  void Write(
      const Inst &inst,
      const std::unordered_map<ConstRef<Inst>, unsigned> &map
  );
  void Write(
      ConstRef<Value> value,
      const std::unordered_map<ConstRef<Inst>, unsigned> &map
  );
  void Write(
      ConstRef<Inst> value,
      const std::unordered_map<ConstRef<Inst>, unsigned> &map
  );
  void Write(
      const Block *value,
      const std::unordered_map<ConstRef<Inst>, unsigned> &map
  );
  void Write(ConstRef<Constant> value);
  void Write(const Expr &expr);
  void Write(const Global &global);
  void Write(const Annot &annot);
  void Write(const Xtor &xtor);
  void Write(Type type);
  void Write(const TypeFlag &type);
  void Write(const FlaggedType &type);
 
  void Emit(llvm::StringRef str);
  void Emit(const std::string &str) { return Emit(llvm::StringRef(str)); }
  template<typename T> void Emit(T t);
 
private:
  std::unordered_map<const Global *, unsigned> symbols_;
  llvm::raw_pwrite_stream &os_;
};