119 lines
4.4 KiB
C++
119 lines
4.4 KiB
C++
//===- 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
|