Operator.cpp | Explore in Territory

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

#include "mlir/TableGen/Operator.h"
#include "mlir/TableGen/Argument.h"
#include "mlir/TableGen/Predicate.h"
#include "mlir/TableGen/Trait.h"
#include "mlir/TableGen/Type.h"
#include "llvm/ADT/EquivalenceClasses.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Sequence.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/TypeSwitch.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/TableGen/Error.h"
#include "llvm/TableGen/Record.h"
#include <list>

#define DEBUG_TYPE …

usingnamespacemlir;
usingnamespacemlir::tblgen;

DagInit;
DefInit;
Record;

Operator::Operator(const llvm::Record &def)
    : … { … }

std::string Operator::getOperationName() const { … }

std::string Operator::getAdaptorName() const { … }

std::string Operator::getGenericAdaptorName() const { … }

/// Assert the invariants of accessors generated for the given name.
static void assertAccessorInvariants(const Operator &op, StringRef name) { … }

void Operator::assertInvariants() const { … }

StringRef Operator::getDialectName() const { … }

StringRef Operator::getCppClassName() const { … }

std::string Operator::getQualCppClassName() const { … }

StringRef Operator::getCppNamespace() const { … }

int Operator::getNumResults() const { … }

StringRef Operator::getExtraClassDeclaration() const { … }

StringRef Operator::getExtraClassDefinition() const { … }

const llvm::Record &Operator::getDef() const { … }

bool Operator::skipDefaultBuilders() const { … }

auto Operator::result_begin() const -> const_value_iterator { … }

auto Operator::result_end() const -> const_value_iterator { … }

auto Operator::getResults() const -> const_value_range { … }

TypeConstraint Operator::getResultTypeConstraint(int index) const { … }

StringRef Operator::getResultName(int index) const { … }

auto Operator::getResultDecorators(int index) const -> var_decorator_range { … }

unsigned Operator::getNumVariableLengthResults() const { … }

unsigned Operator::getNumVariableLengthOperands() const { … }

bool Operator::hasSingleVariadicArg() const { … }

Operator::arg_iterator Operator::arg_begin() const { … }

Operator::arg_iterator Operator::arg_end() const { … }

Operator::arg_range Operator::getArgs() const { … }

StringRef Operator::getArgName(int index) const { … }

auto Operator::getArgDecorators(int index) const -> var_decorator_range { … }

const Trait *Operator::getTrait(StringRef trait) const { … }

auto Operator::region_begin() const -> const_region_iterator { … }
auto Operator::region_end() const -> const_region_iterator { … }
auto Operator::getRegions() const
    -> llvm::iterator_range<const_region_iterator> { … }

unsigned Operator::getNumRegions() const { … }

const NamedRegion &Operator::getRegion(unsigned index) const { … }

unsigned Operator::getNumVariadicRegions() const { … }

auto Operator::successor_begin() const -> const_successor_iterator { … }
auto Operator::successor_end() const -> const_successor_iterator { … }
auto Operator::getSuccessors() const
    -> llvm::iterator_range<const_successor_iterator> { … }

unsigned Operator::getNumSuccessors() const { … }

const NamedSuccessor &Operator::getSuccessor(unsigned index) const { … }

unsigned Operator::getNumVariadicSuccessors() const { … }

auto Operator::trait_begin() const -> const_trait_iterator { … }
auto Operator::trait_end() const -> const_trait_iterator { … }
auto Operator::getTraits() const -> llvm::iterator_range<const_trait_iterator> { … }

auto Operator::attribute_begin() const -> const_attribute_iterator { … }
auto Operator::attribute_end() const -> const_attribute_iterator { … }
auto Operator::getAttributes() const
    -> llvm::iterator_range<const_attribute_iterator> { … }
auto Operator::attribute_begin() -> attribute_iterator { … }
auto Operator::attribute_end() -> attribute_iterator { … }
auto Operator::getAttributes() -> llvm::iterator_range<attribute_iterator> { … }

auto Operator::operand_begin() const -> const_value_iterator { … }
auto Operator::operand_end() const -> const_value_iterator { … }
auto Operator::getOperands() const -> const_value_range { … }

auto Operator::getArg(int index) const -> Argument { … }

bool Operator::isVariadic() const { … }

void Operator::populateTypeInferenceInfo(
    const llvm::StringMap<int> &argumentsAndResultsIndex) { … }

void Operator::populateOpStructure() { … }

const InferredResultType &Operator::getInferredResultType(int index) const { … }

ArrayRef<SMLoc> Operator::getLoc() const { … }

bool Operator::hasDescription() const { … }

StringRef Operator::getDescription() const { … }

bool Operator::hasSummary() const { … }

StringRef Operator::getSummary() const { … }

bool Operator::hasAssemblyFormat() const { … }

StringRef Operator::getAssemblyFormat() const { … }

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

auto Operator::VariableDecoratorIterator::unwrap(llvm::Init *init)
    -> VariableDecorator { … }

auto Operator::getArgToOperandOrAttribute(int index) const
    -> OperandOrAttribute { … }

std::string Operator::getGetterName(StringRef name) const { … }

std::string Operator::getSetterName(StringRef name) const { … }

std::string Operator::getRemoverName(StringRef name) const { … }

bool Operator::hasFolder() const { … }

bool Operator::useCustomPropertiesEncoding() const { … }
llvm/mlir/lib/TableGen/Operator.cpp
