Pattern.cpp | Explore in Territory

//===- Pattern.cpp - Pattern wrapper class --------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// Pattern wrapper class to simplify using TableGen Record defining a MLIR
// Pattern.
//
//===----------------------------------------------------------------------===//

#include <utility>

#include "mlir/TableGen/Pattern.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/Twine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/TableGen/Error.h"
#include "llvm/TableGen/Record.h"

#define DEBUG_TYPE …

usingnamespacemlir;
usingnamespacetblgen;

formatv;

//===----------------------------------------------------------------------===//
// DagLeaf
//===----------------------------------------------------------------------===//

bool DagLeaf::isUnspecified() const { … }

bool DagLeaf::isOperandMatcher() const { … }

bool DagLeaf::isAttrMatcher() const { … }

bool DagLeaf::isNativeCodeCall() const { … }

bool DagLeaf::isConstantAttr() const { … }

bool DagLeaf::isEnumAttrCase() const { … }

bool DagLeaf::isStringAttr() const { … }

Constraint DagLeaf::getAsConstraint() const { … }

ConstantAttr DagLeaf::getAsConstantAttr() const { … }

EnumAttrCase DagLeaf::getAsEnumAttrCase() const { … }

std::string DagLeaf::getConditionTemplate() const { … }

llvm::StringRef DagLeaf::getNativeCodeTemplate() const { … }

int DagLeaf::getNumReturnsOfNativeCode() const { … }

std::string DagLeaf::getStringAttr() const { … }
bool DagLeaf::isSubClassOf(StringRef superclass) const { … }

void DagLeaf::print(raw_ostream &os) const { … }

//===----------------------------------------------------------------------===//
// DagNode
//===----------------------------------------------------------------------===//

bool DagNode::isNativeCodeCall() const { … }

bool DagNode::isOperation() const { … }

llvm::StringRef DagNode::getNativeCodeTemplate() const { … }

int DagNode::getNumReturnsOfNativeCode() const { … }

llvm::StringRef DagNode::getSymbol() const { … }

Operator &DagNode::getDialectOp(RecordOperatorMap *mapper) const { … }

int DagNode::getNumOps() const { … }

int DagNode::getNumArgs() const { … }

bool DagNode::isNestedDagArg(unsigned index) const { … }

DagNode DagNode::getArgAsNestedDag(unsigned index) const { … }

DagLeaf DagNode::getArgAsLeaf(unsigned index) const { … }

StringRef DagNode::getArgName(unsigned index) const { … }

bool DagNode::isReplaceWithValue() const { … }

bool DagNode::isLocationDirective() const { … }

bool DagNode::isReturnTypeDirective() const { … }

bool DagNode::isEither() const { … }

bool DagNode::isVariadic() const { … }

void DagNode::print(raw_ostream &os) const { … }

//===----------------------------------------------------------------------===//
// SymbolInfoMap
//===----------------------------------------------------------------------===//

StringRef SymbolInfoMap::getValuePackName(StringRef symbol, int *index) { … }

SymbolInfoMap::SymbolInfo::SymbolInfo(
    const Operator *op, SymbolInfo::Kind kind,
    std::optional<DagAndConstant> dagAndConstant)
    : … { … }

int SymbolInfoMap::SymbolInfo::getStaticValueCount() const { … }

std::string SymbolInfoMap::SymbolInfo::getVarName(StringRef name) const { … }

std::string SymbolInfoMap::SymbolInfo::getVarTypeStr(StringRef name) const { … }

std::string SymbolInfoMap::SymbolInfo::getVarDecl(StringRef name) const { … }

std::string SymbolInfoMap::SymbolInfo::getArgDecl(StringRef name) const { … }

std::string SymbolInfoMap::SymbolInfo::getValueAndRangeUse(
    StringRef name, int index, const char *fmt, const char *separator) const { … }

std::string SymbolInfoMap::SymbolInfo::getAllRangeUse(
    StringRef name, int index, const char *fmt, const char *separator) const { … }

bool SymbolInfoMap::bindOpArgument(DagNode node, StringRef symbol,
                                   const Operator &op, int argIndex,
                                   std::optional<int> variadicSubIndex) { … }

bool SymbolInfoMap::bindOpResult(StringRef symbol, const Operator &op) { … }

bool SymbolInfoMap::bindValues(StringRef symbol, int numValues) { … }

bool SymbolInfoMap::bindValue(StringRef symbol) { … }

bool SymbolInfoMap::bindMultipleValues(StringRef symbol, int numValues) { … }

bool SymbolInfoMap::bindAttr(StringRef symbol) { … }

bool SymbolInfoMap::contains(StringRef symbol) const { … }

SymbolInfoMap::const_iterator SymbolInfoMap::find(StringRef key) const { … }

SymbolInfoMap::const_iterator
SymbolInfoMap::findBoundSymbol(StringRef key, DagNode node, const Operator &op,
                               int argIndex,
                               std::optional<int> variadicSubIndex) const { … }

SymbolInfoMap::const_iterator
SymbolInfoMap::findBoundSymbol(StringRef key,
                               const SymbolInfo &symbolInfo) const { … }

std::pair<SymbolInfoMap::iterator, SymbolInfoMap::iterator>
SymbolInfoMap::getRangeOfEqualElements(StringRef key) { … }

int SymbolInfoMap::count(StringRef key) const { … }

int SymbolInfoMap::getStaticValueCount(StringRef symbol) const { … }

std::string SymbolInfoMap::getValueAndRangeUse(StringRef symbol,
                                               const char *fmt,
                                               const char *separator) const { … }

std::string SymbolInfoMap::getAllRangeUse(StringRef symbol, const char *fmt,
                                          const char *separator) const { … }

void SymbolInfoMap::assignUniqueAlternativeNames() { … }

//===----------------------------------------------------------------------===//
// Pattern
//==----------------------------------------------------------------------===//

Pattern::Pattern(const llvm::Record *def, RecordOperatorMap *mapper)
    : … { … }

DagNode Pattern::getSourcePattern() const { … }

int Pattern::getNumResultPatterns() const { … }

DagNode Pattern::getResultPattern(unsigned index) const { … }

void Pattern::collectSourcePatternBoundSymbols(SymbolInfoMap &infoMap) { … }

void Pattern::collectResultPatternBoundSymbols(SymbolInfoMap &infoMap) { … }

const Operator &Pattern::getSourceRootOp() { … }

Operator &Pattern::getDialectOp(DagNode node) { … }

std::vector<AppliedConstraint> Pattern::getConstraints() const { … }

int Pattern::getNumSupplementalPatterns() const { … }

DagNode Pattern::getSupplementalPattern(unsigned index) const { … }

int Pattern::getBenefit() const { … }

std::vector<Pattern::IdentifierLine> Pattern::getLocation() const { … }

void Pattern::verifyBind(bool result, StringRef symbolName) { … }

void Pattern::collectBoundSymbols(DagNode tree, SymbolInfoMap &infoMap,
                                  bool isSrcPattern) { … }
llvm/mlir/lib/TableGen/Pattern.cpp
