control.hpp

Go to the documentation of this file.

/*
 * Copyright 2010 2011 2012 2014 Helge Bahmann <hcb@chaoticmind.net>
 * Copyright 2014 2015 Nico Reißmann <nico.reissmann@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_RVSDG_CONTROL_HPP
#define JLM_RVSDG_CONTROL_HPP
 
#include <jlm/rvsdg/bitstring/type.hpp>
#include <jlm/rvsdg/node.hpp>
#include <jlm/rvsdg/nullary.hpp>
#include <jlm/rvsdg/unary.hpp>
#include <jlm/util/strfmt.hpp>
 
#include <cstdint>
#include <unordered_map>
 
namespace jlm::rvsdg
{
 
class ControlType final : public Type
{
public:
  ~ControlType() noexcept override;
 
  explicit ControlType(size_t nalternatives);
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  bool
  operator==(const jlm::rvsdg::Type & other) const noexcept override;
 
  std::size_t
  ComputeHash() const noexcept override;
 
  TypeKind
  Kind() const noexcept override;
 
  inline size_t
  nalternatives() const noexcept
  {
    return nalternatives_;
  }
 
  static std::shared_ptr<const ControlType>
  Create(std::size_t nalternatives);
 
private:
  size_t nalternatives_;
};
 
class ControlValueRepresentation
{
public:
  ControlValueRepresentation(size_t alternative, size_t nalternatives);
 
  inline bool
  operator==(const ControlValueRepresentation & other) const noexcept
  {
    return alternative_ == other.alternative_ && nalternatives_ == other.nalternatives_;
  }
 
  inline bool
  operator!=(const ControlValueRepresentation & other) const noexcept
  {
    return !(*this == other);
  }
 
  inline size_t
  alternative() const noexcept
  {
    return alternative_;
  }
 
  inline size_t
  nalternatives() const noexcept
  {
    return nalternatives_;
  }
 
private:
  size_t alternative_;
  size_t nalternatives_;
};
 
class ControlConstantOperation final : public NullaryOperation
{
public:
  ~ControlConstantOperation() noexcept override;
 
  explicit ControlConstantOperation(ControlValueRepresentation value);
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  [[nodiscard]] const ControlValueRepresentation &
  value() const noexcept
  {
    return value_;
  }
 
  static Output &
  create(Region & region, ControlValueRepresentation value)
  {
    return *CreateOpNode<ControlConstantOperation>(region, std::move(value)).output(0);
  }
 
  static Output &
  create(Region & region, size_t numAlternatives, size_t alternative)
  {
    return create(region, { alternative, numAlternatives });
  }
 
  static Output &
  createFalse(Region & region)
  {
    return create(region, 2, 0);
  }
 
  static Output &
  createTrue(Region & region)
  {
    return create(region, 2, 1);
  }
 
private:
  ControlValueRepresentation value_;
};
 
class MatchOperation final : public UnaryOperation
{
  typedef std::unordered_map<uint64_t, uint64_t>::const_iterator const_iterator;
 
public:
  ~MatchOperation() noexcept override;
 
  MatchOperation(
      size_t nbits,
      const std::unordered_map<uint64_t, uint64_t> & mapping,
      uint64_t default_alternative,
      size_t nalternatives);
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  unop_reduction_path_t
  can_reduce_operand(const jlm::rvsdg::Output * arg) const noexcept override;
 
  jlm::rvsdg::Output *
  reduce_operand(unop_reduction_path_t path, jlm::rvsdg::Output * arg) const override;
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  inline uint64_t
  nalternatives() const noexcept
  {
    return std::static_pointer_cast<const ControlType>(result(0))->nalternatives();
  }
 
  inline uint64_t
  alternative(uint64_t value) const noexcept
  {
    auto it = mapping_.find(value);
    if (it != mapping_.end())
      return it->second;
 
    return default_alternative_;
  }
 
  inline uint64_t
  default_alternative() const noexcept
  {
    return default_alternative_;
  }
 
  inline size_t
  nbits() const noexcept
  {
    return std::static_pointer_cast<const BitType>(argument(0))->nbits();
  }
 
  inline const_iterator
  begin() const
  {
    return mapping_.begin();
  }
 
  inline const_iterator
  end() const
  {
    return mapping_.end();
  }
 
  static Node &
  CreateNode(
      Output & predicate,
      const std::unordered_map<uint64_t, uint64_t> & mapping,
      const uint64_t defaultAlternative,
      const size_t numAlternatives)
  {
    const auto bitType = CheckAndExtractBitType(*predicate.Type());
    return CreateOpNode<MatchOperation>(
        { &predicate },
        bitType.nbits(),
        mapping,
        defaultAlternative,
        numAlternatives);
  }
 
  static Output *
  Create(
      Output & predicate,
      const std::unordered_map<uint64_t, uint64_t> & mapping,
      const uint64_t defaultAlternative,
      const size_t numAlternatives)
  {
    return CreateNode(predicate, mapping, defaultAlternative, numAlternatives).output(0);
  }
 
private:
  static const BitType &
  CheckAndExtractBitType(const rvsdg::Type & type)
  {
    if (auto bitType = dynamic_cast<const BitType *>(&type))
    {
      return *bitType;
    }
 
    throw util::TypeError("BitType", type.debug_string());
  }
 
  uint64_t default_alternative_;
  std::unordered_map<uint64_t, uint64_t> mapping_;
};
 
jlm::rvsdg::Output *
match(
    size_t nbits,
    const std::unordered_map<uint64_t, uint64_t> & mapping,
    uint64_t default_alternative,
    size_t nalternatives,
    jlm::rvsdg::Output * operand);
 
}
 
#endif