annot_printer.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 <optional>
#include <set>
 
#include <llvm/Pass.h>
#include <llvm/IR/DataLayout.h>
#include <llvm/MC/MCStreamer.h>
#include <llvm/MC/MCObjectFileInfo.h>
#include <llvm/Target/TargetMachine.h>
#include <llvm/CodeGen/MachineFunctionPass.h>
#include <llvm/CodeGen/TargetSubtargetInfo.h>
 
#include "core/adt/hash.h"
#include "core/annot.h"
 
class Prog;
class MovInst;
class X86ISel;
class ISelMapping;
 
 
 
class AnnotPrinter : public llvm::ModulePass {
public:
  AnnotPrinter(
      char &ID,
      llvm::MCContext *ctx,
      llvm::MCStreamer *os,
      const llvm::MCObjectFileInfo *objInfo,
      const llvm::DataLayout &layout,
      const ISelMapping &mapping,
      bool shared
  );
 
protected:
  virtual std::optional<unsigned> GetRegisterIndex(llvm::Register reg) = 0;
  virtual llvm::StringRef GetRegisterName(unsigned reg) = 0;
  virtual llvm::Register GetStackPointer() = 0;
  virtual unsigned GetImplicitStackSize() const = 0;
 
  virtual int64_t GetFrameOffset(const llvm::MachineInstr &MI) const
  {
    return 0;
  }
 
private:
  bool runOnModule(llvm::Module &M) override;
  void getAnalysisUsage(llvm::AnalysisUsage &AU) const override;
 
private:
  struct FrameInfo {
    llvm::MCSymbol *Label;
    int64_t Offset;
    int16_t FrameSize;
    std::set<uint16_t> Live;
    std::vector<size_t> Allocs;
    std::vector<llvm::MCSymbol *> Debug;
  };
 
  struct RootInfo {
    llvm::MCSymbol *Label;
    int64_t Offset;
 
    RootInfo(llvm::MCSymbol *label, int64_t offset)
        : Label(label), Offset(offset)
    {
    }
  };
 
  struct DebugKey {
    const CamlFrame::DebugInfos &Debug;
 
    bool operator==(const DebugKey &that) const {
      return Debug == that.Debug;
    }
  };
 
  struct DebugKeyHash {
    size_t operator() (const DebugKey &key) const {
      size_t hash = 0;
      for (const auto &debug : key.Debug) {
        ::hash_combine(hash, std::hash<int64_t>{}(debug.Location));
        ::hash_combine(hash, std::hash<std::string>{}(debug.File));
        ::hash_combine(hash, std::hash<std::string>{}(debug.Definition));
      }
      return hash;
    }
  };
 
  struct DebugInfo {
    llvm::MCSymbol *Definition;
    int64_t Location;
  };
 
  struct DebugInfos {
    llvm::MCSymbol *Symbol;
    std::vector<DebugInfo> Debug;
  };
 
  struct DefinitionInfo {
    llvm::MCSymbol *Symbol;
    llvm::MCSymbol *File;
    std::string Definition;
  };
 
  void LowerFrame(const FrameInfo &frame);
  llvm::MCSymbol *LowerSymbol(const std::string_view name);
  llvm::MCSymbol *RecordDebug(const CamlFrame::DebugInfos &debug);
  llvm::MCSymbol *RecordDefinition(
      const std::string &file,
      const std::string &def
  );
  llvm::MCSymbol *RecordFile(const std::string &file);
  void EmitDiff(llvm::MCSymbol *symbol, unsigned size = 4);
  void EmitOffset(llvm::MCSymbol *symbol, int64_t off);
 
protected:
  const ISelMapping &mapping_;
  llvm::MCContext *ctx_;
  llvm::MCStreamer *os_;
  const llvm::MCObjectFileInfo *objInfo_;
  const llvm::DataLayout layout_;
  std::vector<FrameInfo> frames_;
  std::vector<RootInfo> roots_;
  std::unordered_map<DebugKey, DebugInfos, DebugKeyHash> debug_;
  std::unordered_map<
    std::pair<std::string, std::string>,
    DefinitionInfo
  > defs_;
  std::unordered_map<std::string, llvm::MCSymbol *> files_;
  bool shared_;
};