//===- PatternParser.h ------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
/// \file Contains tools to parse MIR patterns from TableGen DAG elements.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_UTILS_GLOBALISEL_PATTERNPARSER_H
#define LLVM_UTILS_GLOBALISEL_PATTERNPARSER_H

#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/STLFunctionalExtras.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/Support/SMLoc.h"
#include <memory>

namespace llvm {
class CodeGenTarget;
class DagInit;
class Init;
class Record;
class StringRef;
class StringInit;

namespace gi {
class InstructionPattern;
class Pattern;
class PatFrag;

/// Helper class to parse MIR Pattern lists.
///
/// e.g., `(match (G_FADD $x, $y, $z), (G_FNEG $y, $z))`
class PatternParser {
  const CodeGenTarget &CGT;
  ArrayRef<SMLoc> DiagLoc;

  mutable SmallPtrSet<const PatFrag *, 2> SeenPatFrags;

public:
  PatternParser(const CodeGenTarget &CGT, ArrayRef<SMLoc> DiagLoc)
      : CGT(CGT), DiagLoc(DiagLoc) {}

  /// Parses a list of patterns such as:
  ///   (Operator (Pattern1 ...), (Pattern2 ...))
  /// \param List         DagInit of the expected pattern list.
  /// \param ParseAction  Callback to handle a succesfully parsed pattern.
  /// \param Operator     The name of the operator, e.g. "match"
  /// \param AnonPatNamePrefix Prefix for anonymous pattern names.
  /// \return true on success, false on failure.
  bool
  parsePatternList(const DagInit &List,
                   function_ref<bool(std::unique_ptr<Pattern>)> ParseAction,
                   StringRef Operator, StringRef AnonPatNamePrefix);

  /// \returns all PatFrags encountered by this PatternParser.
  const auto &getSeenPatFrags() const { return SeenPatFrags; }

private:
  /// Parse any InstructionPattern from a TableGen Init.
  /// \param Arg Init to parse.
  /// \param PatName Name of the pattern that will be parsed.
  /// \return the parsed pattern on success, nullptr on failure.
  std::unique_ptr<Pattern> parseInstructionPattern(const Init &Arg,
                                                   StringRef PatName);

  /// Parse a WipOpcodeMatcher from a TableGen Init.
  /// \param Arg Init to parse.
  /// \param PatName Name of the pattern that will be parsed.
  /// \return the parsed pattern on success, nullptr on failure.
  std::unique_ptr<Pattern> parseWipMatchOpcodeMatcher(const Init &Arg,
                                                      StringRef PatName);

  /// Parses an Operand of an InstructionPattern from a TableGen Init.
  /// \param IP InstructionPattern for which we're parsing.
  /// \param OpInit Init to parse.
  /// \param OpName Name of the operand to parse.
  /// \return true on success, false on failure.
  bool parseInstructionPatternOperand(InstructionPattern &IP,
                                      const Init *OpInit,
                                      const StringInit *OpName);

  /// Parses a MIFlag for an InstructionPattern from a TableGen Init.
  /// \param IP InstructionPattern for which we're parsing.
  /// \param Op Init to parse.
  /// \return true on success, false on failure.
  bool parseInstructionPatternMIFlags(InstructionPattern &IP,
                                      const DagInit *Op);

  /// (Uncached) PatFrag parsing implementation.
  /// \param Def PatFrag def to parsee.
  /// \return the parsed PatFrag on success, nullptr on failure.
  std::unique_ptr<PatFrag> parsePatFragImpl(const Record *Def);

  /// Parses the in or out parameter list of a PatFrag.
  /// \param OpsList Init to parse.
  /// \param ParseAction Callback on successful parse, with the name of
  ///                     the parameter and its \ref PatFrag::ParamKind
  /// \return true on success, false on failure.
  bool
  parsePatFragParamList(const DagInit &OpsList,
                        function_ref<bool(StringRef, unsigned)> ParseAction);

  /// Cached PatFrag parser. This avoids duplicate work by keeping track of
  /// already-parsed PatFrags.
  /// \param Def PatFrag def to parsee.
  /// \return the parsed PatFrag on success, nullptr on failure.
  const PatFrag *parsePatFrag(const Record *Def);
};

} // namespace gi
} // namespace llvm

#endif