mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-26 18:46:06 +00:00
d8399d5dd6
Give the properties from tablegen a `predicate` field that holds the predicate that the property needs to satisfy, if one exists, and hook that field up to verifier generation.
111 lines
4.4 KiB
C++
111 lines
4.4 KiB
C++
//===- Property.cpp - Property 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Property wrapper to simplify using TableGen Record defining a MLIR
|
|
// Property.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "mlir/TableGen/Property.h"
|
|
#include "mlir/TableGen/Format.h"
|
|
#include "mlir/TableGen/Operator.h"
|
|
#include "mlir/TableGen/Predicate.h"
|
|
#include "llvm/TableGen/Record.h"
|
|
|
|
using namespace mlir;
|
|
using namespace mlir::tblgen;
|
|
|
|
using llvm::DefInit;
|
|
using llvm::Init;
|
|
using llvm::Record;
|
|
using llvm::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) {
|
|
if (const auto *str = dyn_cast<StringInit>(init))
|
|
return str->getValue().trim();
|
|
return {};
|
|
}
|
|
|
|
Property::Property(const Record *def)
|
|
: Property(
|
|
getValueAsString(def->getValueInit("summary")),
|
|
getValueAsString(def->getValueInit("description")),
|
|
getValueAsString(def->getValueInit("storageType")),
|
|
getValueAsString(def->getValueInit("interfaceType")),
|
|
getValueAsString(def->getValueInit("convertFromStorage")),
|
|
getValueAsString(def->getValueInit("assignToStorage")),
|
|
getValueAsString(def->getValueInit("convertToAttribute")),
|
|
getValueAsString(def->getValueInit("convertFromAttribute")),
|
|
getValueAsString(def->getValueInit("parser")),
|
|
getValueAsString(def->getValueInit("optionalParser")),
|
|
getValueAsString(def->getValueInit("printer")),
|
|
getValueAsString(def->getValueInit("readFromMlirBytecode")),
|
|
getValueAsString(def->getValueInit("writeToMlirBytecode")),
|
|
getValueAsString(def->getValueInit("hashProperty")),
|
|
getValueAsString(def->getValueInit("defaultValue")),
|
|
getValueAsString(def->getValueInit("storageTypeValueOverride"))) {
|
|
this->def = def;
|
|
assert((def->isSubClassOf("Property") || def->isSubClassOf("Attr")) &&
|
|
"must be subclass of TableGen 'Property' class");
|
|
}
|
|
|
|
Property::Property(const DefInit *init) : Property(init->getDef()) {}
|
|
|
|
Property::Property(StringRef summary, StringRef description,
|
|
StringRef storageType, StringRef interfaceType,
|
|
StringRef convertFromStorageCall,
|
|
StringRef assignToStorageCall,
|
|
StringRef convertToAttributeCall,
|
|
StringRef convertFromAttributeCall, StringRef parserCall,
|
|
StringRef optionalParserCall, StringRef printerCall,
|
|
StringRef readFromMlirBytecodeCall,
|
|
StringRef writeToMlirBytecodeCall,
|
|
StringRef hashPropertyCall, StringRef defaultValue,
|
|
StringRef storageTypeValueOverride)
|
|
: def(nullptr), summary(summary), description(description),
|
|
storageType(storageType), interfaceType(interfaceType),
|
|
convertFromStorageCall(convertFromStorageCall),
|
|
assignToStorageCall(assignToStorageCall),
|
|
convertToAttributeCall(convertToAttributeCall),
|
|
convertFromAttributeCall(convertFromAttributeCall),
|
|
parserCall(parserCall), optionalParserCall(optionalParserCall),
|
|
printerCall(printerCall),
|
|
readFromMlirBytecodeCall(readFromMlirBytecodeCall),
|
|
writeToMlirBytecodeCall(writeToMlirBytecodeCall),
|
|
hashPropertyCall(hashPropertyCall), defaultValue(defaultValue),
|
|
storageTypeValueOverride(storageTypeValueOverride) {
|
|
if (storageType.empty())
|
|
storageType = "Property";
|
|
}
|
|
|
|
StringRef Property::getPropertyDefName() const {
|
|
if (def->isAnonymous()) {
|
|
return getBaseProperty().def->getName();
|
|
}
|
|
return def->getName();
|
|
}
|
|
|
|
Pred Property::getPredicate() const {
|
|
if (!def)
|
|
return Pred();
|
|
const llvm::RecordVal *maybePred = def->getValue("predicate");
|
|
if (!maybePred || !maybePred->getValue())
|
|
return Pred();
|
|
return Pred(maybePred->getValue());
|
|
}
|
|
|
|
Property Property::getBaseProperty() const {
|
|
if (const auto *defInit =
|
|
llvm::dyn_cast<llvm::DefInit>(def->getValueInit("baseProperty"))) {
|
|
return Property(defInit).getBaseProperty();
|
|
}
|
|
return *this;
|
|
}
|