/*

  This file is part of solidity.

  solidity is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  solidity is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with solidity.  If not, see <http://www.gnu.org/licenses/>.

*/

// SPDX-License-Identifier: GPL-3.0

/**

 * @file SimplificationRules

 * @author Christian <chris@ethereum.org>

 * @date 2017

 * Module for applying replacement rules against Expressions.

 */

#pragma once

#include <libevmasm/ExpressionClasses.h>

#include <libevmasm/SimplificationRule.h>

#include <libsolutil/CommonData.h>

#include <functional>

#include <vector>

namespace solidity::langutil

{

struct SourceLocation;

}

namespace solidity::evmasm

{

class Pattern;

/**

 * Container for all simplification rules.

 */

class Rules

{

public:

  /// Noncopyable.

  Rules(Rules const&) = delete;

  Rules& operator=(Rules const&) = delete;

  Rules();

  /// @returns a pointer to the first matching pattern and sets the match

  /// groups accordingly.

  SimplificationRule<Pattern> const* findFirstMatch(

    Expression const& _expr,

    ExpressionClasses const& _classes

  );

  /// Checks whether the rulelist is non-empty. This is usually enforced

  /// by the constructor, but we had some issues with static initialization.

  bool isInitialized() const;

private:

  void addRules(std::vector<SimplificationRule<Pattern>> const& _rules);

  void addRule(SimplificationRule<Pattern> const& _rule);

  void resetMatchGroups() { m_matchGroups.clear(); }

  std::map<unsigned, Expression const*> m_matchGroups;

  /// Pattern to match, replacement to be applied and flag indicating whether

  /// the replacement might remove some elements (except constants).

  std::vector<SimplificationRule<Pattern>> m_rules[256];

};

/**

 * Pattern to match against an expression.

 * Also stores matched expressions to retrieve them later, for constructing new expressions using

 * ExpressionTemplate.

 */

class Pattern

{

public:

  using Id = ExpressionClasses::Id;

  using Builtins = evmasm::EVMBuiltins<Pattern>;

  static constexpr size_t WordSize = 256;

  using Word = u256;

  // Matches a specific constant value.

  Pattern(unsigned _value): Pattern(u256(_value)) {}

  Pattern(int _value): Pattern(u256(_value)) {}

  Pattern(long unsigned _value): Pattern(u256(_value)) {}

  // Matches a specific constant value.

  Pattern(u256 const& _value): m_type(Push), m_requireDataMatch(true), m_data(std::make_shared<u256>(_value)) {}

  // Matches a specific assembly item type or anything if not given.

  Pattern(AssemblyItemType _type = UndefinedItem): m_type(_type) {}

  // Matches a given instruction with given arguments

  Pattern(Instruction _instruction, std::initializer_list<Pattern> _arguments = {});

  /// Sets this pattern to be part of the match group with the identifier @a _group.

  /// Inside one rule, all patterns in the same match group have to match expressions from the

  /// same expression equivalence class.

  void setMatchGroup(unsigned _group, std::map<unsigned, Expression const*>& _matchGroups);

  unsigned matchGroup() const { return m_matchGroup; }

  bool matches(Expression const& _expr, ExpressionClasses const& _classes) const;

  AssemblyItem toAssemblyItem(langutil::DebugData::ConstPtr _debugData) const;

  std::vector<Pattern> arguments() const { return m_arguments; }

  /// @returns the id of the matched expression if this pattern is part of a match group.

  Id id() const { return matchGroupValue().id; }

  /// @returns the data of the matched expression if this pattern is part of a match group.

  u256 const& d() const { return matchGroupValue().item->data(); }

  std::string toString() const;

  AssemblyItemType type() const { return m_type; }

  Instruction instruction() const

  {

    assertThrow(type() == Operation, OptimizerException, "");

    return m_instruction;

  }

private:

  bool matchesBaseItem(AssemblyItem const* _item) const;

  Expression const& matchGroupValue() const;

  u256 const& data() const;

  AssemblyItemType m_type;

  bool m_requireDataMatch = false;

  Instruction m_instruction; ///< Only valid if m_type is Operation

  std::shared_ptr<u256> m_data; ///< Only valid if m_type is not Operation

  std::vector<Pattern> m_arguments;

  unsigned m_matchGroup = 0;

  std::map<unsigned, Expression const*>* m_matchGroups = nullptr;

};

/**

 * Template for a new expression that can be built from matched patterns.

 */

struct ExpressionTemplate

{

  using Id = ExpressionClasses::Id;

  explicit ExpressionTemplate(Pattern const& _pattern, langutil::DebugData::ConstPtr const& _debugData);

  std::string toString() const;

  bool hasId = false;

  /// Id of the matched expression, if available.

  Id id = Id(-1);

  // Otherwise, assembly item.

  AssemblyItem item = UndefinedItem;

  std::vector<ExpressionTemplate> arguments;

};

}