parser.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 <llvm/ADT/StringRef.h>
 
#include <fstream>
#include <list>
#include <optional>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
 
#include "core/adt/hash.h"
#include "core/adt/sexp.h"
#include "core/calling_conv.h"
#include "core/error.h"
#include "core/inst.h"
#include "core/lexer.h"
#include "core/visibility.h"
#include "core/xtor.h"
 
class Atom;
class Block;
class Context;
class Data;
class Const;
class Func;
class Prog;
class Object;
 
 
 
class Parser final {
private:
  using Token = Lexer::Token;
  using VRegMap = std::unordered_map<ConstRef<Inst>, unsigned>;
 
  struct Section {
    std::optional<unsigned> Align;
    Data *D = nullptr;
    Object *O = nullptr;
    Atom *A = nullptr;
    Func *F = nullptr;
    VRegMap VRegs;
 
    Section(Data *data) : D(data) {}
  };
 
public:
  Parser(llvm::StringRef buf, std::string_view ident);
 
  ~Parser();
 
  std::unique_ptr<Prog> Parse();
 
private:
  void ParseDirective(const std::string_view op);
  // Segment directives.
  void ParseSection(bool push);
  // Other directives.
  void ParseAlign();
  void ParseP2Align();
  void ParseEnd();
  void ParseSpace();
  void ParseAscii();
  void ParseAsciz();
  void ParseItem(Type ty);
  void ParseItems(Type ty);
  void ParseComm(Visibility visibility);
  void ParseDouble();
  // Function and segment attributes.
  void ParseFeatures();
  void ParseStackObject();
  void ParseCall();
  void ParseArgs();
  void ParsePersonality();
  void ParseVararg();
  void ParseVisibility();
  void ParseNoInline();
  void ParseGlobl();
  void ParseHidden();
  void ParseWeak();
  void ParseThreadLocal();
  void ParsePopSection();
  // Ignored directives.
  void ParseFile();
  void ParseLocal();
  void ParseIdent();
  void ParseAddrsig();
  void ParseAddrsigSym();
  void ParseProtected();
  void ParseSet();
  void ParseExtern();
  void ParseXtor(Xtor::Kind kind);
 
  void CreateBlock(Func *func, const std::string_view name);
 
  Section &GetSection();
  Object *GetOrCreateObject();
  Atom *GetOrCreateAtom();
  Func *GetFunction();
  void EndFunction();
  void Align(int64_t alignment);
  void End();
 
  [[nodiscard]] static llvm::Error PhiPlacement(Func &func, VRegMap vregs);
 
  template<typename T>
  T ParseToken(
      const std::vector<std::pair<const char *, T>> &options,
      const std::string_view str
  );
 
  int64_t Number();
  Type ParseType(std::string_view str);
  TypeFlag ParseTypeFlags(const std::string_view op);
  CallingConv ParseCallingConv(const std::string_view str);
  Visibility ParseVisibility(const std::string_view str);
  std::string_view ParseName(std::string_view ident);
 
private:
  class Operand {
  public:
    enum class Kind {
      REGISTER,
      VALUE,
    };
 
  public:
 
    Operand(Register reg) : kind_(Kind::REGISTER), reg_(reg) {}
    Operand(Value *val) : kind_(Kind::VALUE), val_(val) {}
 
    std::optional<uintptr_t> ToVReg() const
    {
      if (kind_ == Kind::VALUE) {
        auto val = reinterpret_cast<uintptr_t>(val_);
        return (val & 1) == 1 ? std::optional<uintptr_t>(val) : std::nullopt;
      }
      return {};
    }
 
    std::optional<Value *> ToVal() const
    {
      if (kind_ == Kind::VALUE) return val_;
      return {};
    }
 
    std::optional<Register> ToReg() const
    {
      if (kind_ == Kind::REGISTER) return reg_;
      return {};
    }
 
  private:
    Kind kind_;
 
    union {
      Value *val_;
      Register reg_;
    };
  };
 
  void ParseInstruction(
      const std::string_view op,
      Func *func,
      VRegMap &vregs
  );
  Inst *CreateInst(
      Func *func,
      Block *block,
      const std::string &op,
      const std::vector<Operand> &ops,
      const std::vector<std::pair<unsigned, TypeFlag>> &flags,
      const std::optional<Cond> &ccs,
      const std::optional<size_t> &sizes,
      const std::vector<Type> &ts,
      const std::optional<CallingConv> &conv,
      bool strict,
      AnnotSet &&annot
  );
  void ParseAnnotation(const std::string_view name, AnnotSet &annot);
 
private:
  Lexer l_;
  std::unique_ptr<Prog> prog_;
  uint64_t nextLabel_;
  std::unordered_set<std::string> globls_;
  std::unordered_set<std::string> hidden_;
  std::unordered_set<std::string> weak_;
  std::stack<Section> stk_;
};