Attribute.cpp | Explore in Territory

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

#include "mlir/TableGen/Format.h"
#include "mlir/TableGen/Operator.h"
#include "llvm/TableGen/Record.h"

usingnamespacemlir;
usingnamespacemlir::tblgen;

DefInit;
Init;
Record;
StringInit;

// Returns the initializer's value as string if the given TableGen initializer
// is a code or string initializer. Returns the empty StringRef otherwise.
static StringRef getValueAsString(const Init *init) { … }

bool AttrConstraint::isSubClassOf(StringRef className) const { … }

Attribute::Attribute(const Record *record) : … { … }

Attribute::Attribute(const DefInit *init) : … { … }

bool Attribute::isDerivedAttr() const { … }

bool Attribute::isTypeAttr() const { … }

bool Attribute::isSymbolRefAttr() const { … }

bool Attribute::isEnumAttr() const { … }

StringRef Attribute::getStorageType() const { … }

StringRef Attribute::getReturnType() const { … }

// Return the type constraint corresponding to the type of this attribute, or
// std::nullopt if this is not a TypedAttr.
std::optional<Type> Attribute::getValueType() const { … }

StringRef Attribute::getConvertFromStorageCall() const { … }

bool Attribute::isConstBuildable() const { … }

StringRef Attribute::getConstBuilderTemplate() const { … }

Attribute Attribute::getBaseAttr() const { … }

bool Attribute::hasDefaultValue() const { … }

StringRef Attribute::getDefaultValue() const { … }

bool Attribute::isOptional() const { … }

StringRef Attribute::getAttrDefName() const { … }

StringRef Attribute::getDerivedCodeBody() const { … }

Dialect Attribute::getDialect() const { … }

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

ConstantAttr::ConstantAttr(const DefInit *init) : … { … }

Attribute ConstantAttr::getAttribute() const { … }

StringRef ConstantAttr::getConstantValue() const { … }

EnumAttrCase::EnumAttrCase(const llvm::Record *record) : … { … }

EnumAttrCase::EnumAttrCase(const llvm::DefInit *init)
    : … { … }

StringRef EnumAttrCase::getSymbol() const { … }

StringRef EnumAttrCase::getStr() const { … }

int64_t EnumAttrCase::getValue() const { … }

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

EnumAttr::EnumAttr(const llvm::Record *record) : … { … }

EnumAttr::EnumAttr(const llvm::Record &record) : … { … }

EnumAttr::EnumAttr(const llvm::DefInit *init) : … { … }

bool EnumAttr::classof(const Attribute *attr) { … }

bool EnumAttr::isBitEnum() const { … }

StringRef EnumAttr::getEnumClassName() const { … }

StringRef EnumAttr::getCppNamespace() const { … }

StringRef EnumAttr::getUnderlyingType() const { … }

StringRef EnumAttr::getUnderlyingToSymbolFnName() const { … }

StringRef EnumAttr::getStringToSymbolFnName() const { … }

StringRef EnumAttr::getSymbolToStringFnName() const { … }

StringRef EnumAttr::getSymbolToStringFnRetType() const { … }

StringRef EnumAttr::getMaxEnumValFnName() const { … }

std::vector<EnumAttrCase> EnumAttr::getAllCases() const { … }

bool EnumAttr::genSpecializedAttr() const { … }

llvm::Record *EnumAttr::getBaseAttrClass() const { … }

StringRef EnumAttr::getSpecializedAttrClassName() const { … }

bool EnumAttr::printBitEnumPrimaryGroups() const { … }

const char * ::mlir::tblgen::inferTypeOpInterface = …;
llvm/mlir/lib/TableGen/Attribute.cpp
