specialise.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 <set>
 
#include "core/pass.h"
 
class Func;
class CallSite;
 
 
 
class SpecialisePass final : public Pass {
public:
  static const char *kPassID;
 
  SpecialisePass(PassManager *passManager) : Pass(passManager) {}
 
  bool Run(Prog &prog) override;
 
  const char *GetPassName() const override;
 
private:
  class SpecialiseClone;
 
  struct Parameter {
    enum class Kind {
      INT,
      FLOAT,
      GLOBAL
    };
 
    struct G {
      Global *Symbol;
      int64_t Offset;
 
      G(const G &that) : Symbol(that.Symbol), Offset(that.Offset) {}
      G(Global *symbol, int64_t offset) : Symbol(symbol), Offset(offset) {}
 
      bool operator==(const G &that) const
      {
        return Symbol == that.Symbol && Offset == that.Offset;
      }
    };
 
    Parameter(const Parameter &that);
    Parameter(const APInt &v) : K(Kind::INT), IntVal(v) {}
    Parameter(const APFloat &v) : K(Kind::FLOAT), FloatVal(v) {}
    Parameter(Global *g, int64_t i) : K(Kind::GLOBAL), GlobalVal(g, i) {}
    ~Parameter();
 
    bool operator==(const Parameter &that) const;
 
    Parameter &operator=(const Parameter &that);
 
    Value *ToValue() const;
 
    Kind K;
 
    union {
      APInt IntVal;
      APFloat FloatVal;
      G GlobalVal;
    };
  };
 
  using Parameters = std::map<unsigned, Parameter>;
 
  struct ParameterHash {
    size_t operator()(const Parameter &param) const;
  };
  struct ParametersHash {
    size_t operator()(const Parameters &param) const;
  };
 
  void Specialise(
      Func *func,
      const Parameters &params,
      const std::set<CallSite *> &callSites
  );
  Func *Specialise(Func *oldFunc, const Parameters &params);
  std::pair<std::vector<Ref<Inst>>, std::vector<TypeFlag>>
  Specialise(CallSite *inst, const Parameters &params);
};