func.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 <string_view>
 
#include <llvm/ADT/ArrayRef.h>
#include <llvm/ADT/DenseMap.h>
#include <llvm/ADT/ilist_node.h>
#include <llvm/ADT/ilist.h>
#include <llvm/Support/raw_ostream.h>
 
#include "core/calling_conv.h"
#include "core/global.h"
#include "core/symbol_table.h"
#include "core/type.h"
#include "core/value.h"
 
class Block;
class Func;
class Prog;
 
 
 
class Func final : public llvm::ilist_node_with_parent<Func, Prog>, public Global {
public:
  static constexpr Global::Kind kGlobalKind = Global::Kind::FUNC;
 
public:
  using BlockListType = SymbolTableList<Block>;
 
  using iterator = BlockListType::iterator;
  using reverse_iterator = BlockListType::reverse_iterator;
  using const_iterator = BlockListType::const_iterator;
 
public:
  struct StackObject {
    unsigned Index;
    unsigned Size;
    llvm::Align Alignment;
 
    StackObject(unsigned index, unsigned size, llvm::Align alignment)
      : Index(index)
      , Size(size)
      , Alignment(alignment)
    {
    }
  };
 
  using stack_iterator = std::vector<StackObject>::iterator;
 
public:
  Func(
      const std::string_view name,
      Visibility visibility = Visibility::LOCAL
  );
 
  ~Func() override;
 
  unsigned GetID() { return id_; }
 
  void removeFromParent() override;
  void eraseFromParent() override;
 
  void AddBlock(Block *block, Block *before = nullptr);
 
  Prog *getParent() const { return parent_; }
 
  unsigned AddStackObject(unsigned index, unsigned size, llvm::Align align);
  void RemoveStackObject(unsigned index);
 
  void SetCallingConv(CallingConv conv) { callConv_ = conv; }
  CallingConv GetCallingConv() const { return callConv_; }
 
  void SetVarArg(bool varArg = true) { varArg_ = varArg; }
  bool IsVarArg() const { return varArg_; }
 
  void SetAlignment(llvm::Align align) { align_ = align; }
  std::optional<llvm::Align> GetAlignment() const override { return align_; }
 
  bool IsNoInline() const { return noinline_; }
  void SetNoInline(bool noinline = true) { noinline_ = noinline; }
 
  std::string_view GetFeatures() const { return features_; }
  llvm::StringRef getFeatures() const { return features_; }
  void SetFeatures(const std::string_view features) { features_ = features; }
 
  std::string_view GetCPU() const { return cpu_; }
  llvm::StringRef getCPU() const { return cpu_; }
  void SetCPU(const std::string_view cpu) { cpu_ = cpu; }
 
  std::string_view GetTuneCPU() const { return tuneCPU_; }
  llvm::StringRef getTuneCPU() const { return tuneCPU_; }
  void SetTuneCPU(const std::string_view tuneCPU) { tuneCPU_ = tuneCPU; }
 
  void SetParameters(const std::vector<FlaggedType> &params) { params_ = params; }
  llvm::ArrayRef<FlaggedType> params() const { return params_; }
  unsigned GetNumParams() const { return params_.size(); }
 
  void SetPersonality(Global *func);
  ConstRef<Global> GetPersonality() const;
 
  llvm::ArrayRef<StackObject> objects() const { return objects_; }
 
  StackObject &object(unsigned I)
  {
    auto it = objectIndices_.find(I);
    assert(it != objectIndices_.end() && "missing stack object");
    return objects_[it->second];
  }
  const StackObject &object(unsigned I) const
  {
    return const_cast<Func *>(this)->object(I);
  }
 
  void remove(iterator it);
  void erase(iterator it);
  void insertAfter(iterator it, Block *block);
  void insert(iterator it, Block *block);
  void clear();
 
  bool empty() const { return blocks_.empty(); }
 
  size_t size() const { return blocks_.size(); }
 
  bool HasAddressTaken() const;
  bool IsEntry() const { return IsRoot() || HasAddressTaken(); }
  bool DoesNotReturn() const;
  bool HasRaise() const;
  bool HasVAStart() const;
  bool HasIndirectCalls() const;
 
  Block &getEntryBlock();
  const Block &getEntryBlock() const {
    return const_cast<Func *>(this)->getEntryBlock();
  }
 
  // Iterator over the blocks.
  iterator begin() { return blocks_.begin(); }
  iterator end() { return blocks_.end(); }
  const_iterator begin() const { return blocks_.begin(); }
  const_iterator end() const { return blocks_.end(); }
 
  // Reverse iterator over the blocks.
  reverse_iterator rbegin() { return blocks_.rbegin(); }
  reverse_iterator rend() { return blocks_.rend(); }
 
  // Counts the number of instructions.
  size_t inst_size() const;
 
  void RemoveUnreachable();
 
  Prog *getProg() override { return parent_; }
 
  void dump(llvm::raw_ostream &os = llvm::errs()) const override;
 
private:
  friend struct SymbolTableListTraits<Func>;
  friend struct SymbolTableListTraits<Block>;
  void setParent(Prog *parent) { parent_ = parent; }
 
  static BlockListType Func::*getSublistAccess(Block *) { return &Func::blocks_; }
 
private:
  unsigned id_;
  Prog *parent_;
  BlockListType blocks_;
  CallingConv callConv_;
  std::vector<FlaggedType> params_;
  std::vector<StackObject> objects_;
  llvm::DenseMap<unsigned, unsigned> objectIndices_;
  bool varArg_;
  std::optional<llvm::Align> align_;
  bool noinline_;
  std::string features_;
  std::string cpu_;
  std::string tuneCPU_;
};