annot.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/ilist_node.h>
#include <llvm/ADT/ilist.h>
#include <llvm/ADT/iterator_range.h>
 
 
class Annot : public llvm::ilist_node<Annot> {
public:
  enum class Kind {
    PROBABILITY = 0,
    CAML_FRAME  = 1,
    CXX_LSDA    = 2,
  };
 
public:
  Annot(Kind kind) : kind_(kind) {}
 
  bool Is(Kind kind) const { return GetKind() == kind; }
  Kind GetKind() const { return kind_; }
 
  bool operator==(const Annot &annot) const;
 
private:
  Kind kind_;
};
 
class Probability final : public Annot {
public:
  static constexpr Annot::Kind kAnnotKind = Kind::PROBABILITY;
 
public:
  Probability(uint32_t n, uint32_t d);
 
  uint32_t GetNumerator() const { return n_; };
  uint32_t GetDenumerator() const { return d_; }
 
  bool operator==(const Probability &that) const;
 
private:
  uint32_t n_;
  uint32_t d_;
};
 
class AnnotSet {
private:
  using AnnotListType = llvm::ilist<Annot>;
 
public:
  using iterator = AnnotListType::iterator;
  using const_iterator = AnnotListType::const_iterator;
 
public:
  AnnotSet();
  AnnotSet(AnnotSet &&that);
  AnnotSet(const AnnotSet &that);
 
  ~AnnotSet();
 
  template<typename T>
  bool Has() const
  {
    for (auto &annot : annots_) {
      if (annot.Is(T::kAnnotKind)) {
        return true;
      }
    }
    return false;
  }
 
  template<typename T, typename... Args>
  bool Set(Args&&... args)
  {
    for (auto &annot : annots_) {
      if (annot.Is(T::kAnnotKind)) {
        return false;
      }
    }
 
    annots_.push_back(new T(std::move(args)...));
    return true;
  }
 
  template<typename T>
  bool Clear()
  {
    for (auto it = annots_.begin(); it != annots_.end(); ) {
      auto jt = it++;
      if (jt->Is(T::kAnnotKind)) {
        annots_.erase(jt);
        return true;
      }
    }
    return false;
  }
 
  template<typename T>
  const T *Get() const
  {
    for (auto it = annots_.begin(); it != annots_.end(); ++it) {
      if (it->Is(T::kAnnotKind)) {
        return static_cast<const T *>(&*it);
      }
    }
    return nullptr;
  }
 
  template<typename T>
  AnnotSet Without() const
  {
    AnnotSet that;
    for (auto &annot : annots_) {
      if (!annot.Is(T::kAnnotKind)) {
        that.Add(annot);
      }
    }
    return that;
  }
 
  bool Add(const Annot &annot);
 
  bool operator == (const AnnotSet &that) const;
  bool operator != (const AnnotSet &that) const { return !(*this == that); }
 
  AnnotSet &operator=(AnnotSet &&that);
 
  size_t size() const { return annots_.size(); }
  bool empty() const { return annots_.empty(); }
  iterator begin() { return annots_.begin(); }
  iterator end() { return annots_.end(); }
  const_iterator begin() const { return annots_.begin(); }
  const_iterator end() const { return annots_.end(); }
 
private:
  AnnotListType annots_;
};
 
class CamlFrame final : public Annot {
public:
  static constexpr Annot::Kind kAnnotKind = Kind::CAML_FRAME;
 
public:
  struct DebugInfo {
    int64_t Location;
    std::string File;
    std::string Definition;
 
    bool operator==(const DebugInfo &that) const {
      if (Location != that.Location) {
        return false;
      }
      if (File != that.File) {
        return false;
      }
      if (Definition != that.Definition) {
        return false;
      }
      return true;
    }
  };
 
  using DebugInfos = std::vector<DebugInfo>;
 
  using const_alloc_iterator = std::vector<size_t>::const_iterator;
  using const_debug_infos_iterator = std::vector<DebugInfos>::const_iterator;
 
public:
  CamlFrame() : Annot(Kind::CAML_FRAME) {}
  CamlFrame(
      std::vector<size_t> &&allocs,
      std::vector<DebugInfos> &&debug_infos
  );
 
  size_t alloc_size() const { return allocs_.size(); }
  llvm::iterator_range<const_alloc_iterator> allocs() const
  {
    return { allocs_.begin(), allocs_.end() };
  }
 
  size_t debug_info_size() const { return debug_infos_.size(); }
  llvm::iterator_range<const_debug_infos_iterator> debug_infos() const
  {
    return { debug_infos_.begin(), debug_infos_.end() };
  }
 
  bool operator==(const CamlFrame &annot) const;
 
private:
  std::vector<size_t> allocs_;
  std::vector<DebugInfos> debug_infos_;
};
 
class CxxLSDA final : public Annot {
public:
  static constexpr Annot::Kind kAnnotKind = Kind::CXX_LSDA;
 
  using const_type_iterator = std::vector<std::string>::const_iterator;
 
public:
  CxxLSDA(
      bool cleanup,
      bool catchAll,
      std::vector<std::string> &&catches,
      std::vector<std::string> &&filters)
    : Annot(Kind::CXX_LSDA)
    , cleanup_(cleanup)
    , catchAll_(catchAll)
    , catches_(std::move(catches))
    , filters_(std::move(filters))
  {
  }
 
  bool IsCleanup() const { return cleanup_; }
  bool IsCatchAll() const { return catchAll_; }
 
  size_t catch_size() const { return catches_.size(); }
  llvm::iterator_range<const_type_iterator> catches() const
  {
    return { catches_.begin(), catches_.end() };
  }
 
  size_t filter_size() const { return filters_.size(); }
  llvm::iterator_range<const_type_iterator> filters() const
  {
    return { filters_.begin(), filters_.end() };
  }
 
private:
  bool cleanup_;
  bool catchAll_;
  std::vector<std::string> catches_;
  std::vector<std::string> filters_;
};