31 #include "llvm/ADT/APFloat.h"
32 #include "llvm/ADT/ArrayRef.h"
33 #include "llvm/ADT/DenseMap.h"
34 #include "llvm/ADT/MapVector.h"
35 #include "llvm/ADT/STLExtras.h"
36 #include "llvm/ADT/ScopeExit.h"
37 #include "llvm/ADT/ScopedHashTable.h"
38 #include "llvm/ADT/SetVector.h"
39 #include "llvm/ADT/StringExtras.h"
40 #include "llvm/ADT/StringSet.h"
41 #include "llvm/ADT/TypeSwitch.h"
42 #include "llvm/Support/CommandLine.h"
43 #include "llvm/Support/Debug.h"
44 #include "llvm/Support/Endian.h"
45 #include "llvm/Support/ManagedStatic.h"
46 #include "llvm/Support/Regex.h"
47 #include "llvm/Support/SaveAndRestore.h"
48 #include "llvm/Support/Threading.h"
49 #include "llvm/Support/raw_ostream.h"
50 #include <type_traits>
58 #define DEBUG_TYPE "mlir-asm-printer"
79 [&]() {
return parseType(result.emplace_back()); });
95 auto &os = getStream();
99 *this << (operand ? operand.getType() : Type());
115 *this << (result ? result.getType() : Type());
127 #include "mlir/IR/OpAsmAttrInterface.cpp.inc"
128 #include "mlir/IR/OpAsmOpInterface.cpp.inc"
129 #include "mlir/IR/OpAsmTypeInterface.cpp.inc"
133 return entry.
emitError() <<
"unknown 'resource' key '" << entry.
getKey()
134 <<
"' for dialect '" << getDialect()->getNamespace()
146 struct AsmPrinterOptions {
147 llvm::cl::opt<int64_t> printElementsAttrWithHexIfLarger{
148 "mlir-print-elementsattrs-with-hex-if-larger",
150 "Print DenseElementsAttrs with a hex string that have "
151 "more elements than the given upper limit (use -1 to disable)")};
153 llvm::cl::opt<unsigned> elideElementsAttrIfLarger{
154 "mlir-elide-elementsattrs-if-larger",
155 llvm::cl::desc(
"Elide ElementsAttrs with \"...\" that have "
156 "more elements than the given upper limit")};
158 llvm::cl::opt<unsigned> elideResourceStringsIfLarger{
159 "mlir-elide-resource-strings-if-larger",
161 "Elide printing value of resources if string is too long in chars.")};
163 llvm::cl::opt<bool> printDebugInfoOpt{
164 "mlir-print-debuginfo", llvm::cl::init(
false),
165 llvm::cl::desc(
"Print debug info in MLIR output")};
167 llvm::cl::opt<bool> printPrettyDebugInfoOpt{
168 "mlir-pretty-debuginfo", llvm::cl::init(
false),
169 llvm::cl::desc(
"Print pretty debug info in MLIR output")};
173 llvm::cl::opt<bool> printGenericOpFormOpt{
174 "mlir-print-op-generic", llvm::cl::init(
false),
175 llvm::cl::desc(
"Print the generic op form"), llvm::cl::Hidden};
177 llvm::cl::opt<bool> assumeVerifiedOpt{
178 "mlir-print-assume-verified", llvm::cl::init(
false),
179 llvm::cl::desc(
"Skip op verification when using custom printers"),
182 llvm::cl::opt<bool> printLocalScopeOpt{
183 "mlir-print-local-scope", llvm::cl::init(
false),
184 llvm::cl::desc(
"Print with local scope and inline information (eliding "
185 "aliases for attributes, types, and locations)")};
187 llvm::cl::opt<bool> skipRegionsOpt{
188 "mlir-print-skip-regions", llvm::cl::init(
false),
189 llvm::cl::desc(
"Skip regions when printing ops.")};
191 llvm::cl::opt<bool> printValueUsers{
192 "mlir-print-value-users", llvm::cl::init(
false),
194 "Print users of operation results and block arguments as a comment")};
196 llvm::cl::opt<bool> printUniqueSSAIDs{
197 "mlir-print-unique-ssa-ids", llvm::cl::init(
false),
198 llvm::cl::desc(
"Print unique SSA ID numbers for values, block arguments "
199 "and naming conflicts across all regions")};
201 llvm::cl::opt<bool> useNameLocAsPrefix{
202 "mlir-use-nameloc-as-prefix", llvm::cl::init(
false),
203 llvm::cl::desc(
"Print SSA IDs using NameLocs as prefixes")};
207 static llvm::ManagedStatic<AsmPrinterOptions>
clOptions;
218 : printDebugInfoFlag(false), printDebugInfoPrettyFormFlag(false),
219 printGenericOpFormFlag(false), skipRegionsFlag(false),
220 assumeVerifiedFlag(false), printLocalScope(false),
221 printValueUsersFlag(false), printUniqueSSAIDsFlag(false),
222 useNameLocAsPrefix(false) {
226 if (
clOptions->elideElementsAttrIfLarger.getNumOccurrences())
227 elementsAttrElementLimit =
clOptions->elideElementsAttrIfLarger;
228 if (
clOptions->printElementsAttrWithHexIfLarger.getNumOccurrences())
229 elementsAttrHexElementLimit =
230 clOptions->printElementsAttrWithHexIfLarger.getValue();
231 if (
clOptions->elideResourceStringsIfLarger.getNumOccurrences())
232 resourceStringCharLimit =
clOptions->elideResourceStringsIfLarger;
233 printDebugInfoFlag =
clOptions->printDebugInfoOpt;
234 printDebugInfoPrettyFormFlag =
clOptions->printPrettyDebugInfoOpt;
235 printGenericOpFormFlag =
clOptions->printGenericOpFormOpt;
236 assumeVerifiedFlag =
clOptions->assumeVerifiedOpt;
237 printLocalScope =
clOptions->printLocalScopeOpt;
238 skipRegionsFlag =
clOptions->skipRegionsOpt;
239 printValueUsersFlag =
clOptions->printValueUsers;
240 printUniqueSSAIDsFlag =
clOptions->printUniqueSSAIDs;
241 useNameLocAsPrefix =
clOptions->useNameLocAsPrefix;
250 elementsAttrElementLimit = largeElementLimit;
256 elementsAttrHexElementLimit = largeElementLimit;
262 resourceStringCharLimit = largeResourceLimit;
270 printDebugInfoFlag = enable;
271 printDebugInfoPrettyFormFlag = prettyForm;
277 printGenericOpFormFlag = enable;
283 skipRegionsFlag = skip;
289 assumeVerifiedFlag = enable;
297 printLocalScope = enable;
303 printValueUsersFlag = enable;
310 printUniqueSSAIDsFlag = enable;
316 return elementsAttrElementLimit &&
317 *elementsAttrElementLimit < int64_t(attr.getNumElements()) &&
318 !llvm::isa<SplatElementsAttr>(attr);
324 return (elementsAttrHexElementLimit != -1) &&
325 (elementsAttrHexElementLimit < int64_t(attr.getNumElements())) &&
326 !llvm::isa<SplatElementsAttr>(attr);
330 useNameLocAsPrefix = enable;
336 return elementsAttrElementLimit;
341 return elementsAttrHexElementLimit;
346 return resourceStringCharLimit;
351 return printDebugInfoFlag;
356 return printDebugInfoPrettyFormFlag;
361 return printGenericOpFormFlag;
369 return assumeVerifiedFlag;
377 return printValueUsersFlag;
387 return useNameLocAsPrefix;
398 struct NewLineCounter {
399 unsigned curLine = 1;
402 static raw_ostream &
operator<<(raw_ostream &os, NewLineCounter &newLine) {
421 template <
typename Container,
typename UnaryFunctor>
423 llvm::interleaveComma(c,
os, eachFn);
470 function_ref<
void(
unsigned,
bool)> printValueName =
nullptr);
483 bool withKeyword =
false);
486 bool isTopLevel =
false);
522 function_ref<
void(
unsigned,
bool)> printValueName =
nullptr);
546 SymbolAlias(StringRef name, uint32_t suffixIndex,
bool isType,
548 : name(name), suffixIndex(suffixIndex), isType(isType),
549 isDeferrable(isDeferrable) {}
552 void print(raw_ostream &os)
const {
553 os << (isType ?
"!" :
"#") << name;
555 if (isdigit(name.back()))
562 bool isTypeAlias()
const {
return isType; }
565 bool canBeDeferred()
const {
return isDeferrable; }
571 uint32_t suffixIndex : 30;
575 bool isDeferrable : 1;
579 bool isPrinted =
false;
585 class AliasInitializer {
589 llvm::BumpPtrAllocator &aliasAllocator)
590 : interfaces(interfaces), aliasAllocator(aliasAllocator),
591 aliasOS(aliasBuffer) {}
594 llvm::MapVector<const void *, SymbolAlias> &attrTypeToAlias);
602 std::pair<size_t, size_t>
visit(
Attribute attr,
bool canBeDeferred =
false,
603 bool elideType =
false) {
604 return visitImpl(attr, aliases, canBeDeferred, elideType);
611 std::pair<size_t, size_t>
visit(
Type type,
bool canBeDeferred =
false) {
612 return visitImpl(type, aliases, canBeDeferred);
616 struct InProgressAliasInfo {
617 InProgressAliasInfo()
618 : aliasDepth(0), isType(false), canBeDeferred(false) {}
619 InProgressAliasInfo(StringRef alias)
620 : alias(alias), aliasDepth(1), isType(false), canBeDeferred(false) {}
622 bool operator<(
const InProgressAliasInfo &rhs)
const {
624 if (aliasDepth != rhs.aliasDepth)
625 return aliasDepth < rhs.aliasDepth;
626 if (isType != rhs.isType)
628 return alias < rhs.alias;
633 std::optional<StringRef> alias;
636 unsigned aliasDepth : 30;
640 bool canBeDeferred : 1;
650 template <
typename T,
typename... PrintArgs>
651 std::pair<size_t, size_t>
653 llvm::MapVector<const void *, InProgressAliasInfo> &aliases,
654 bool canBeDeferred, PrintArgs &&...printArgs);
657 void markAliasNonDeferrable(
size_t aliasIndex);
661 template <
typename T>
662 void generateAlias(T symbol, InProgressAliasInfo &alias,
bool canBeDeferred);
667 uniqueAliasNameIndex(StringRef alias, llvm::StringMap<unsigned> &nameCounts,
672 static void initializeAliases(
673 llvm::MapVector<const void *, InProgressAliasInfo> &visitedSymbols,
674 llvm::MapVector<const void *, SymbolAlias> &symbolToAlias);
680 llvm::BumpPtrAllocator &aliasAllocator;
683 llvm::MapVector<const void *, InProgressAliasInfo> aliases;
687 llvm::raw_svector_ostream aliasOS;
695 class DummyAliasOperationPrinter :
private OpAsmPrinter {
697 explicit DummyAliasOperationPrinter(
const OpPrintingFlags &printerFlags,
698 AliasInitializer &initializer)
699 : printerFlags(printerFlags), initializer(initializer) {}
703 void printCustomOrGenericOp(
Operation *op)
override {
705 if (printerFlags.shouldPrintDebugInfo())
706 initializer.visit(op->
getLoc(),
true);
709 if (!printerFlags.shouldPrintGenericOpForm()) {
720 void printGenericOp(
Operation *op,
bool printOpName =
true)
override {
722 if (!printerFlags.shouldSkipRegions()) {
736 printAttribute(attr.getValue());
742 void print(
Block *block,
bool printBlockArgs =
true,
743 bool printBlockTerminator =
true) {
746 if (printBlockArgs) {
751 if (printerFlags.shouldPrintDebugInfo())
753 initializer.visit(arg.getLoc(),
false);
761 auto range = llvm::make_range(
763 std::prev(block->
end(),
764 (!hasTerminator || printBlockTerminator) ? 0 : 1));
766 printCustomOrGenericOp(&op);
771 bool printBlockTerminators,
772 bool printEmptyBlock =
false)
override {
775 if (printerFlags.shouldSkipRegions()) {
780 auto *entryBlock = ®ion.
front();
781 print(entryBlock, printEntryBlockArgs, printBlockTerminators);
782 for (
Block &b : llvm::drop_begin(region, 1))
787 bool omitType)
override {
790 if (printerFlags.shouldPrintDebugInfo())
792 initializer.visit(arg.
getLoc(),
false);
796 void printType(
Type type)
override { initializer.visit(type); }
799 void printAttribute(
Attribute attr)
override { initializer.visit(attr); }
800 void printAttributeWithoutType(
Attribute attr)
override {
801 printAttribute(attr);
807 LogicalResult printAlias(
Attribute attr)
override {
808 initializer.visit(attr);
811 LogicalResult printAlias(
Type type)
override {
812 initializer.visit(type);
817 void printOptionalLocationSpecifier(
Location loc)
override {
827 if (elidedAttrs.empty()) {
829 printAttribute(attr.getValue());
832 llvm::SmallDenseSet<StringRef> elidedAttrsSet(elidedAttrs.begin(),
835 if (!elidedAttrsSet.contains(attr.getName().strref()))
836 printAttribute(attr.getValue());
838 void printOptionalAttrDictWithKeyword(
841 printOptionalAttrDict(attrs, elidedAttrs);
846 raw_ostream &getStream()
const override {
return os; }
850 void printFloat(
const APFloat &)
override {}
851 void printAffineMapOfSSAIds(AffineMapAttr,
ValueRange)
override {}
854 void increaseIndent()
override {}
855 void decreaseIndent()
override {}
856 void printOperand(
Value)
override {}
857 void printOperand(
Value, raw_ostream &os)
override {
866 void printSymbolName(StringRef)
override {}
867 void printSuccessor(
Block *)
override {}
875 AliasInitializer &initializer;
878 mutable llvm::raw_null_ostream os;
883 explicit DummyAliasDialectAsmPrinter(AliasInitializer &initializer,
886 : initializer(initializer), canBeDeferred(canBeDeferred),
887 childIndices(childIndices) {}
892 template <
typename T,
typename... PrintArgs>
893 size_t printAndVisitNestedAliases(T value, PrintArgs &&...printArgs) {
894 printAndVisitNestedAliasesImpl(value, printArgs...);
895 return maxAliasDepth;
901 void printAndVisitNestedAliasesImpl(
Attribute attr,
bool elideType) {
902 if (!isa<BuiltinDialect>(attr.
getDialect())) {
906 }
else if (llvm::isa<AffineMapAttr, DenseArrayAttr, FloatAttr, IntegerAttr,
907 IntegerSetAttr, UnitAttr>(attr)) {
909 }
else if (
auto distinctAttr = dyn_cast<DistinctAttr>(attr)) {
910 printAttribute(distinctAttr.getReferencedAttr());
911 }
else if (
auto dictAttr = dyn_cast<DictionaryAttr>(attr)) {
913 printAttribute(nestedAttr.getName());
914 printAttribute(nestedAttr.getValue());
916 }
else if (
auto arrayAttr = dyn_cast<ArrayAttr>(attr)) {
917 for (
Attribute nestedAttr : arrayAttr.getValue())
918 printAttribute(nestedAttr);
919 }
else if (
auto typeAttr = dyn_cast<TypeAttr>(attr)) {
921 }
else if (
auto locAttr = dyn_cast<OpaqueLoc>(attr)) {
922 printAttribute(locAttr.getFallbackLocation());
923 }
else if (
auto locAttr = dyn_cast<NameLoc>(attr)) {
924 if (!isa<UnknownLoc>(locAttr.getChildLoc()))
925 printAttribute(locAttr.getChildLoc());
926 }
else if (
auto locAttr = dyn_cast<CallSiteLoc>(attr)) {
927 printAttribute(locAttr.getCallee());
928 printAttribute(locAttr.getCaller());
929 }
else if (
auto locAttr = dyn_cast<FusedLoc>(attr)) {
930 if (
Attribute metadata = locAttr.getMetadata())
931 printAttribute(metadata);
932 for (
Location nestedLoc : locAttr.getLocations())
933 printAttribute(nestedLoc);
938 if (
auto typedAttr = llvm::dyn_cast<TypedAttr>(attr)) {
939 Type attrType = typedAttr.getType();
940 if (!llvm::isa<NoneType>(attrType))
945 void printAndVisitNestedAliasesImpl(
Type type) {
950 if (
auto memrefTy = llvm::dyn_cast<MemRefType>(type)) {
952 MemRefLayoutAttrInterface layout = memrefTy.getLayout();
953 if (!llvm::isa<AffineMapAttr>(layout) || !layout.isIdentity())
954 printAttribute(memrefTy.getLayout());
955 if (memrefTy.getMemorySpace())
956 printAttribute(memrefTy.getMemorySpace());
961 auto visitFn = [&](
auto element) {
963 (void)printAlias(element);
970 recordAliasResult(initializer.visit(type, canBeDeferred));
974 void printAttribute(
Attribute attr)
override {
975 recordAliasResult(initializer.visit(attr, canBeDeferred));
977 void printAttributeWithoutType(
Attribute attr)
override {
979 initializer.visit(attr, canBeDeferred,
true));
985 LogicalResult printAlias(
Attribute attr)
override {
986 printAttribute(attr);
989 LogicalResult printAlias(
Type type)
override {
995 void recordAliasResult(std::pair<size_t, size_t> aliasDepthAndIndex) {
996 childIndices.push_back(aliasDepthAndIndex.second);
997 if (aliasDepthAndIndex.first > maxAliasDepth)
998 maxAliasDepth = aliasDepthAndIndex.first;
1003 raw_ostream &getStream()
const override {
return os; }
1007 void printFloat(
const APFloat &)
override {}
1010 void printSymbolName(StringRef)
override {}
1013 LogicalResult pushCyclicPrinting(
const void *opaquePointer)
override {
1014 return success(cyclicPrintingStack.insert(opaquePointer));
1017 void popCyclicPrinting()
override { cyclicPrintingStack.pop_back(); }
1024 AliasInitializer &initializer;
1033 size_t maxAliasDepth = 0;
1036 mutable llvm::raw_null_ostream os;
1044 StringRef allowedPunctChars =
"$._-") {
1045 assert(!name.empty() &&
"Shouldn't have an empty name here");
1047 auto validChar = [&](
char ch) {
1048 return llvm::isAlnum(ch) || allowedPunctChars.contains(ch);
1051 auto copyNameToBuffer = [&] {
1052 for (
char ch : name) {
1054 buffer.push_back(ch);
1056 buffer.push_back(
'_');
1058 buffer.append(llvm::utohexstr((
unsigned char)ch));
1065 if (isdigit(name[0]) || (!validChar(name[0]) && name[0] !=
' ')) {
1066 buffer.push_back(
'_');
1072 for (
char ch : name) {
1073 if (!validChar(ch)) {
1083 unsigned AliasInitializer::uniqueAliasNameIndex(
1084 StringRef alias, llvm::StringMap<unsigned> &nameCounts,
1086 if (!usedAliases.count(alias)) {
1087 usedAliases.insert(alias);
1094 if (isdigit(alias.back()))
1095 probeAlias.push_back(
'_');
1097 if (nameCounts[probeAlias] == 0)
1098 nameCounts[probeAlias] = 1;
1102 unsigned nameIndex = nameCounts[probeAlias]++;
1103 probeAlias += llvm::utostr(nameIndex);
1104 if (!usedAliases.count(probeAlias)) {
1105 usedAliases.insert(probeAlias);
1109 probeAlias.resize(alias.size() + isdigit(alias.back()) ? 1 : 0);
1115 void AliasInitializer::initializeAliases(
1116 llvm::MapVector<const void *, InProgressAliasInfo> &visitedSymbols,
1117 llvm::MapVector<const void *, SymbolAlias> &symbolToAlias) {
1119 unprocessedAliases = visitedSymbols.takeVector();
1120 llvm::stable_sort(unprocessedAliases, llvm::less_second());
1124 llvm::BumpPtrAllocator usedAliasAllocator;
1127 llvm::StringMap<unsigned> nameCounts;
1128 for (
auto &[symbol, aliasInfo] : unprocessedAliases) {
1129 if (!aliasInfo.alias)
1131 StringRef alias = *aliasInfo.alias;
1132 unsigned nameIndex = uniqueAliasNameIndex(alias, nameCounts, usedAliases);
1133 symbolToAlias.insert(
1134 {symbol, SymbolAlias(alias, nameIndex, aliasInfo.isType,
1135 aliasInfo.canBeDeferred)});
1139 void AliasInitializer::initialize(
1141 llvm::MapVector<const void *, SymbolAlias> &attrTypeToAlias) {
1145 DummyAliasOperationPrinter aliasPrinter(printerFlags, *
this);
1146 aliasPrinter.printCustomOrGenericOp(op);
1149 initializeAliases(aliases, attrTypeToAlias);
1152 template <
typename T,
typename... PrintArgs>
1153 std::pair<size_t, size_t> AliasInitializer::visitImpl(
1154 T value, llvm::MapVector<const void *, InProgressAliasInfo> &aliases,
1155 bool canBeDeferred, PrintArgs &&...printArgs) {
1156 auto [it, inserted] = aliases.try_emplace(value.getAsOpaquePointer());
1157 size_t aliasIndex = std::distance(aliases.begin(), it);
1161 markAliasNonDeferrable(aliasIndex);
1162 return {
static_cast<size_t>(it->second.aliasDepth), aliasIndex};
1166 generateAlias(value, it->second, canBeDeferred);
1167 it->second.isType = std::is_base_of_v<Type, T>;
1168 it->second.canBeDeferred = canBeDeferred;
1172 DummyAliasDialectAsmPrinter printer(*
this, canBeDeferred, childAliases);
1173 size_t maxAliasDepth =
1174 printer.printAndVisitNestedAliases(value, printArgs...);
1177 it = std::next(aliases.begin(), aliasIndex);
1180 it->second.childIndices = std::move(childAliases);
1182 it->second.aliasDepth = maxAliasDepth + 1;
1185 return {(size_t)it->second.aliasDepth, aliasIndex};
1188 void AliasInitializer::markAliasNonDeferrable(
size_t aliasIndex) {
1189 auto *it = std::next(aliases.begin(), aliasIndex);
1193 if (!it->second.canBeDeferred)
1196 it->second.canBeDeferred =
false;
1199 for (
size_t childIndex : it->second.childIndices)
1200 markAliasNonDeferrable(childIndex);
1203 template <
typename T>
1204 void AliasInitializer::generateAlias(T symbol, InProgressAliasInfo &alias,
1205 bool canBeDeferred) {
1210 using InterfaceT = std::conditional_t<std::is_base_of_v<Attribute, T>,
1211 OpAsmAttrInterface, OpAsmTypeInterface>;
1212 if (
auto symbolInterface = dyn_cast<InterfaceT>(symbol)) {
1213 symbolInterfaceResult = symbolInterface.getAlias(aliasOS);
1215 nameBuffer = std::move(aliasBuffer);
1216 assert(!nameBuffer.empty() &&
"expected valid alias name");
1220 if (symbolInterfaceResult != OpAsmDialectInterface::AliasResult::FinalAlias) {
1221 for (
const auto &interface : interfaces) {
1223 interface.getAlias(symbol, aliasOS);
1226 nameBuffer = std::move(aliasBuffer);
1227 assert(!nameBuffer.empty() &&
"expected valid alias name");
1228 if (result == OpAsmDialectInterface::AliasResult::FinalAlias)
1233 if (nameBuffer.empty())
1239 name = name.copy(aliasAllocator);
1240 alias = InProgressAliasInfo(name);
1258 LogicalResult getAlias(
Attribute attr, raw_ostream &os)
const;
1262 LogicalResult getAlias(
Type ty, raw_ostream &os)
const;
1266 void printNonDeferredAliases(
AsmPrinter::Impl &p, NewLineCounter &newLine) {
1267 printAliases(p, newLine,
false);
1272 printAliases(p, newLine,
true);
1282 llvm::MapVector<const void *, SymbolAlias> attrTypeToAlias;
1285 llvm::BumpPtrAllocator aliasAllocator;
1289 void AliasState::initialize(
1292 AliasInitializer initializer(interfaces, aliasAllocator);
1293 initializer.initialize(op, printerFlags, attrTypeToAlias);
1296 LogicalResult AliasState::getAlias(
Attribute attr, raw_ostream &os)
const {
1298 if (it == attrTypeToAlias.end())
1300 it->second.print(os);
1304 LogicalResult AliasState::getAlias(
Type ty, raw_ostream &os)
const {
1306 if (it == attrTypeToAlias.end())
1308 if (!it->second.isPrinted)
1311 it->second.print(os);
1315 void AliasState::printAliases(
AsmPrinter::Impl &p, NewLineCounter &newLine,
1317 auto filterFn = [=](
const auto &aliasIt) {
1318 return aliasIt.second.canBeDeferred() == isDeferred;
1320 for (
auto &[opaqueSymbol, alias] :
1321 llvm::make_filter_range(attrTypeToAlias, filterFn)) {
1325 if (alias.isTypeAlias()) {
1328 alias.isPrinted =
true;
1355 class SSANameState {
1358 enum :
unsigned { NameSentinel = ~0U };
1361 SSANameState() =
default;
1366 void printValueID(
Value value,
bool printResultNo, raw_ostream &stream)
const;
1369 void printOperationID(
Operation *op, raw_ostream &stream)
const;
1376 BlockInfo getBlockInfo(
Block *block);
1385 void numberValuesInRegion(
Region ®ion);
1386 void numberValuesInBlock(
Block &block);
1393 void getResultIDAndNumber(
OpResult result,
Value &lookupValue,
1394 std::optional<int> &lookupResultNo)
const;
1397 void setValueName(
Value value, StringRef name);
1401 StringRef uniqueValueName(StringRef name);
1424 llvm::ScopedHashTable<StringRef, char> usedNames;
1425 llvm::BumpPtrAllocator usedNameAllocator;
1428 unsigned nextValueID = 0;
1430 unsigned nextArgumentID = 0;
1432 unsigned nextConflictID = 0;
1441 : printerFlags(printerFlags) {
1442 llvm::SaveAndRestore valueIDSaver(nextValueID);
1443 llvm::SaveAndRestore argumentIDSaver(nextArgumentID);
1444 llvm::SaveAndRestore conflictIDSaver(nextConflictID);
1449 using UsedNamesScopeTy = llvm::ScopedHashTable<StringRef, char>::ScopeTy;
1450 using NamingContext =
1451 std::tuple<Region *, unsigned, unsigned, unsigned, UsedNamesScopeTy *>;
1454 llvm::BumpPtrAllocator allocator;
1457 auto *topLevelNamesScope =
1458 new (allocator.Allocate<UsedNamesScopeTy>()) UsedNamesScopeTy(usedNames);
1462 nameContext.push_back(std::make_tuple(®ion, nextValueID, nextArgumentID,
1463 nextConflictID, topLevelNamesScope));
1465 numberValuesInOp(*op);
1467 while (!nameContext.empty()) {
1469 UsedNamesScopeTy *parentScope;
1473 std::tie(region, std::ignore, std::ignore, std::ignore, parentScope) =
1474 nameContext.pop_back_val();
1476 std::tie(region, nextValueID, nextArgumentID, nextConflictID,
1477 parentScope) = nameContext.pop_back_val();
1481 while (usedNames.getCurScope() != parentScope) {
1482 usedNames.getCurScope()->~UsedNamesScopeTy();
1483 assert((usedNames.getCurScope() !=
nullptr || parentScope ==
nullptr) &&
1484 "top level parentScope must be a nullptr");
1488 auto *curNamesScope =
new (allocator.Allocate<UsedNamesScopeTy>())
1489 UsedNamesScopeTy(usedNames);
1491 numberValuesInRegion(*region);
1495 nameContext.push_back(std::make_tuple(®ion, nextValueID,
1496 nextArgumentID, nextConflictID,
1501 while (usedNames.getCurScope() !=
nullptr)
1502 usedNames.getCurScope()->~UsedNamesScopeTy();
1505 void SSANameState::printValueID(
Value value,
bool printResultNo,
1506 raw_ostream &stream)
const {
1508 stream <<
"<<NULL VALUE>>";
1512 std::optional<int> resultNo;
1513 auto lookupValue = value;
1517 if (
OpResult result = dyn_cast<OpResult>(value))
1518 getResultIDAndNumber(result, lookupValue, resultNo);
1520 auto it = valueIDs.find(lookupValue);
1521 if (it == valueIDs.end()) {
1522 stream <<
"<<UNKNOWN SSA VALUE>>";
1527 if (it->second != NameSentinel) {
1528 stream << it->second;
1530 auto nameIt = valueNames.find(lookupValue);
1531 assert(nameIt != valueNames.end() &&
"Didn't have a name entry?");
1532 stream << nameIt->second;
1535 if (resultNo && printResultNo)
1536 stream <<
'#' << *resultNo;
1539 void SSANameState::printOperationID(
Operation *op, raw_ostream &stream)
const {
1540 auto it = operationIDs.find(op);
1541 if (it == operationIDs.end()) {
1542 stream <<
"<<UNKNOWN OPERATION>>";
1544 stream <<
'%' << it->second;
1549 auto it = opResultGroups.find(op);
1550 return it == opResultGroups.end() ?
ArrayRef<int>() : it->second;
1553 BlockInfo SSANameState::getBlockInfo(
Block *block) {
1554 auto it = blockNames.find(block);
1555 BlockInfo invalidBlock{-1,
"INVALIDBLOCK"};
1556 return it != blockNames.end() ? it->second : invalidBlock;
1559 void SSANameState::shadowRegionArgs(
Region ®ion,
ValueRange namesToUse) {
1560 assert(!region.
empty() &&
"cannot shadow arguments of an empty region");
1562 "incorrect number of names passed in");
1564 "only KnownIsolatedFromAbove ops can shadow names");
1567 for (
unsigned i = 0, e = namesToUse.size(); i != e; ++i) {
1568 auto nameToUse = namesToUse[i];
1569 if (nameToUse ==
nullptr)
1574 llvm::raw_svector_ostream nameStream(nameStr);
1575 printValueID(nameToUse,
true, nameStream);
1578 assert(valueIDs[nameToReplace] == NameSentinel);
1581 auto name = StringRef(nameStream.str()).drop_front();
1584 valueNames[nameToReplace] = name.copy(usedNameAllocator);
1590 StringRef maybeGetValueNameFromLoc(
Value value, StringRef name) {
1592 return maybeNameLoc.getName();
1597 void SSANameState::numberValuesInRegion(
Region ®ion) {
1599 bool opAsmOpInterfaceUsed =
false;
1600 auto setBlockArgNameFn = [&](
Value arg, StringRef name) {
1601 assert(!valueIDs.count(arg) &&
"arg numbered multiple times");
1602 assert(llvm::cast<BlockArgument>(arg).getOwner()->getParent() == ®ion &&
1603 "arg not defined in current region");
1604 opAsmOpInterfaceUsed =
true;
1606 name = maybeGetValueNameFromLoc(arg, name);
1607 setValueName(arg, name);
1612 if (
auto asmInterface = dyn_cast<OpAsmOpInterface>(op))
1613 asmInterface.getAsmBlockArgumentNames(region, setBlockArgNameFn);
1615 if (!opAsmOpInterfaceUsed) {
1617 if (
auto interface = dyn_cast<OpAsmTypeInterface>(arg.
getType())) {
1618 interface.getAsmName(
1619 [&](StringRef name) { setBlockArgNameFn(arg, name); });
1627 unsigned nextBlockID = 0;
1628 for (
auto &block : region) {
1631 auto blockInfoIt = blockNames.insert({&block, {-1,
""}});
1632 if (blockInfoIt.second) {
1636 llvm::raw_string_ostream(name) <<
"^bb" << nextBlockID;
1637 blockInfoIt.first->second.name = StringRef(name).copy(usedNameAllocator);
1639 blockInfoIt.first->second.ordering = nextBlockID++;
1641 numberValuesInBlock(block);
1645 void SSANameState::numberValuesInBlock(
Block &block) {
1650 llvm::raw_svector_ostream specialName(specialNameBuffer);
1652 if (valueIDs.count(arg))
1655 specialNameBuffer.resize(strlen(
"arg"));
1656 specialName << nextArgumentID++;
1658 StringRef specialNameStr = specialName.str();
1660 specialNameStr = maybeGetValueNameFromLoc(arg, specialNameStr);
1661 setValueName(arg, specialNameStr);
1665 for (
auto &op : block)
1666 numberValuesInOp(op);
1669 void SSANameState::numberValuesInOp(
Operation &op) {
1673 bool opAsmOpInterfaceUsed =
false;
1674 auto setResultNameFn = [&](
Value result, StringRef name) {
1675 assert(!valueIDs.count(result) &&
"result numbered multiple times");
1676 assert(result.
getDefiningOp() == &op &&
"result not defined by 'op'");
1677 opAsmOpInterfaceUsed =
true;
1679 name = maybeGetValueNameFromLoc(result, name);
1680 setValueName(result, name);
1683 if (
int resultNo = llvm::cast<OpResult>(result).getResultNumber())
1684 resultGroups.push_back(resultNo);
1687 auto setBlockNameFn = [&](
Block *block, StringRef name) {
1689 "getAsmBlockArgumentNames callback invoked on a block not directly "
1690 "nested under the current operation");
1691 assert(!blockNames.count(block) &&
"block numbered multiple times");
1694 if (name.data() != tmpBuffer.data()) {
1695 tmpBuffer.append(name);
1696 name = tmpBuffer.str();
1698 name = name.copy(usedNameAllocator);
1699 blockNames[block] = {-1, name};
1703 if (OpAsmOpInterface asmInterface = dyn_cast<OpAsmOpInterface>(&op)) {
1704 asmInterface.getAsmBlockNames(setBlockNameFn);
1705 asmInterface.getAsmResultNames(setResultNameFn);
1707 if (!opAsmOpInterfaceUsed) {
1710 bool allHaveOpAsmTypeInterface =
1712 return isa<OpAsmTypeInterface>(type);
1714 if (allHaveOpAsmTypeInterface) {
1716 auto interface = cast<OpAsmTypeInterface>(result.
getType());
1717 interface.getAsmName(
1718 [&](StringRef name) { setResultNameFn(result, name); });
1725 if (numResults == 0) {
1728 if (operationIDs.try_emplace(&op, nextValueID).second)
1737 setValueName(resultBegin, nameLoc.getName());
1742 if (valueIDs.try_emplace(resultBegin, nextValueID).second)
1746 if (resultGroups.size() != 1) {
1747 llvm::array_pod_sort(resultGroups.begin(), resultGroups.end());
1748 opResultGroups.try_emplace(&op, std::move(resultGroups));
1752 void SSANameState::getResultIDAndNumber(
1754 std::optional<int> &lookupResultNo)
const {
1762 auto resultGroupIt = opResultGroups.find(owner);
1763 if (resultGroupIt == opResultGroups.end()) {
1765 lookupResultNo = resultNo;
1772 const auto *it = llvm::upper_bound(resultGroups, resultNo);
1773 int groupResultNo = 0, groupSize = 0;
1776 if (it == resultGroups.end()) {
1777 groupResultNo = resultGroups.back();
1778 groupSize =
static_cast<int>(owner->
getNumResults()) - resultGroups.back();
1781 groupResultNo = *std::prev(it);
1782 groupSize = *it - groupResultNo;
1787 lookupResultNo = resultNo - groupResultNo;
1788 lookupValue = owner->
getResult(groupResultNo);
1791 void SSANameState::setValueName(
Value value, StringRef name) {
1794 valueIDs[value] = nextValueID++;
1798 valueIDs[value] = NameSentinel;
1799 valueNames[value] = uniqueValueName(name);
1802 StringRef SSANameState::uniqueValueName(StringRef name) {
1807 if (!usedNames.count(name)) {
1808 name = name.copy(usedNameAllocator);
1814 probeName.push_back(
'_');
1816 probeName += llvm::utostr(nextConflictID++);
1817 if (!usedNames.count(probeName)) {
1818 name = probeName.str().copy(usedNameAllocator);
1821 probeName.resize(name.size() + 1);
1825 usedNames.insert(name,
char());
1835 class DistinctState {
1841 uint64_t distinctCounter = 0;
1846 uint64_t DistinctState::getId(
DistinctAttr distinctAttr) {
1847 auto [it, inserted] =
1848 distinctAttrMap.try_emplace(distinctAttr, distinctCounter);
1851 return it->getSecond();
1858 AsmParsedResourceEntry::~AsmParsedResourceEntry() =
default;
1859 AsmResourceBuilder::~AsmResourceBuilder() =
default;
1860 AsmResourceParser::~AsmResourceParser() =
default;
1861 AsmResourcePrinter::~AsmResourcePrinter() =
default;
1865 case AsmResourceEntryKind::Blob:
1867 case AsmResourceEntryKind::Bool:
1869 case AsmResourceEntryKind::String:
1872 llvm_unreachable(
"unknown AsmResourceEntryKind");
1876 std::unique_ptr<ResourceCollection> &collection = keyToResources[key.str()];
1878 collection = std::make_unique<ResourceCollection>(key);
1882 std::vector<std::unique_ptr<AsmResourcePrinter>>
1884 std::vector<std::unique_ptr<AsmResourcePrinter>> printers;
1885 for (
auto &it : keyToResources) {
1886 ResourceCollection *collection = it.second.get();
1888 return collection->buildResources(op, builder);
1890 printers.emplace_back(
1896 LogicalResult FallbackAsmResourceMap::ResourceCollection::parseResource(
1900 FailureOr<AsmResourceBlob> blob = entry.
parseAsBlob();
1903 resources.emplace_back(entry.
getKey(), std::move(*blob));
1910 resources.emplace_back(entry.
getKey(), *value);
1917 resources.emplace_back(entry.
getKey(), std::move(*str));
1924 void FallbackAsmResourceMap::ResourceCollection::buildResources(
1926 for (
const auto &entry : resources) {
1927 if (
const auto *value = std::get_if<AsmResourceBlob>(&entry.value))
1929 else if (
const auto *value = std::get_if<bool>(&entry.value))
1931 else if (
const auto *value = std::get_if<std::string>(&entry.value))
1934 llvm_unreachable(
"unknown AsmResourceEntryKind");
1948 : interfaces(op->
getContext()), nameState(op, printerFlags),
1949 printerFlags(printerFlags), locationMap(locationMap) {}
1952 : interfaces(ctx), printerFlags(printerFlags), locationMap(locationMap) {}
1956 aliasState.initialize(op, printerFlags, interfaces);
1976 return llvm::make_pointee_range(externalResourcePrinters);
1986 (*locationMap)[op] = std::make_pair(line, col);
1992 return dialectResources;
1996 return success(cyclicPrintingStack.insert(opaquePointer));
2012 AliasState aliasState;
2015 SSANameState nameState;
2018 DistinctState distinctState;
2034 template <
typename Range>
2038 [&stream](
const auto &dimSize) {
2039 if (ShapedType::isDynamic(dimSize))
2057 return printerFlags;
2061 auto parentThreadId = llvm::get_threadid();
2063 if (parentThreadId == llvm::get_threadid()) {
2065 diag.print(llvm::dbgs());
2066 llvm::dbgs() <<
"\n";
2072 if (failed(
verify(op))) {
2073 LLVM_DEBUG(llvm::dbgs()
2075 <<
"' failed to verify and will be printed in generic form\n");
2079 return printerFlags;
2098 return impl->getPrinterFlags();
2102 std::unique_ptr<AsmResourcePrinter> printer) {
2103 impl->externalResourcePrinters.emplace_back(std::move(printer));
2108 return impl->getDialectResources();
2116 : os(os), state(state), printerFlags(state.getPrinterFlags()) {}
2124 printLocation(loc, allowAlias);
2130 if (!isTopLevel && succeeded(state.getAliasState().getAlias(loc, os)))
2134 .Case<OpaqueLoc>([&](OpaqueLoc loc) {
2135 printLocationInternal(loc.getFallbackLocation(), pretty);
2137 .Case<UnknownLoc>([&](UnknownLoc loc) {
2145 os << loc.getFilename().getValue();
2147 printEscapedString(loc.getFilename());
2148 if (loc.getEndColumn() == loc.getStartColumn() &&
2149 loc.getStartLine() == loc.getEndLine()) {
2150 os <<
':' << loc.getStartLine() <<
':' << loc.getStartColumn();
2153 if (loc.getStartLine() == loc.getEndLine()) {
2154 os <<
':' << loc.getStartLine() <<
':' << loc.getStartColumn()
2155 <<
" to :" << loc.getEndColumn();
2158 os <<
':' << loc.getStartLine() <<
':' << loc.getStartColumn() <<
" to "
2159 << loc.getEndLine() <<
':' << loc.getEndColumn();
2161 .Case<NameLoc>([&](NameLoc loc) {
2162 printEscapedString(loc.getName());
2165 auto childLoc = loc.getChildLoc();
2166 if (!llvm::isa<UnknownLoc>(childLoc)) {
2168 printLocationInternal(childLoc, pretty);
2172 .Case<CallSiteLoc>([&](CallSiteLoc loc) {
2177 printLocationInternal(callee, pretty);
2179 if (llvm::isa<NameLoc>(callee)) {
2180 if (llvm::isa<FileLineColLoc>(caller)) {
2183 os << newLine <<
" at ";
2186 os << newLine <<
" at ";
2191 printLocationInternal(caller, pretty);
2195 .Case<FusedLoc>([&](
FusedLoc loc) {
2198 if (
Attribute metadata = loc.getMetadata()) {
2206 [&](Location loc) { printLocationInternal(loc, pretty); },
2207 [&]() { os << ", "; });
2210 .Default([&](LocationAttr loc) {
2211 // Assumes that this is a dialect-specific attribute and prints it
2213 printAttribute(loc);
2219 static void printFloatValue(const APFloat &apValue, raw_ostream &os,
2220 bool *printedHex = nullptr) {
2221 // We would like to output the FP constant value in exponential notation,
2222 // but we cannot do this if doing so will lose precision. Check here to
2223 // make sure that we only output it in exponential format if we can parse
2224 // the value back and get the same value.
2225 bool isInf = apValue.isInfinity();
2226 bool isNaN = apValue.isNaN();
2227 if (!isInf && !isNaN) {
2228 SmallString<128> strValue;
2229 apValue.toString(strValue, /*FormatPrecision=*/6, /*FormatMaxPadding=*/0,
2230 /*TruncateZero=*/false);
2232 // Check to make sure that the stringized number is not some string like
2233 // "Inf" or NaN, that atof will accept, but the lexer will not. Check
2234 // that the string matches the "[-+]?[0-9]" regex.
2235 assert(((strValue[0] >= '0
' && strValue[0] <= '9') ||
2236 ((strValue[0] ==
'-' || strValue[0] ==
'+') &&
2237 (strValue[1] >=
'0' && strValue[1] <=
'9'))) &&
2238 "[-+]?[0-9] regex does not match!");
2242 if (APFloat(apValue.getSemantics(), strValue).bitwiseIsEqual(apValue)) {
2250 apValue.toString(strValue);
2253 if (strValue.str().contains(
'.')) {
2264 APInt apInt = apValue.bitcastToAPInt();
2265 apInt.toString(str, 16,
false,
2272 return printLocationInternal(loc,
true,
true);
2276 printLocationInternal(loc,
false,
true);
2285 if (symName.empty() || !isalpha(symName.front()))
2290 symName = symName.drop_while(
2291 [](
char c) {
return llvm::isAlnum(c) || c ==
'.' || c ==
'_'; });
2292 if (symName.empty())
2297 return symName.front() ==
'<' && symName.back() ==
'>';
2302 StringRef dialectName, StringRef symString) {
2303 os << symPrefix << dialectName;
2308 os <<
'.' << symString;
2312 os << '<' << symString << '>
';
2316 static bool isBareIdentifier(StringRef name) {
2317 // By making this unsigned, the value passed in to isalnum will always be
2318 // in the range 0-255. This is important when building with MSVC because
2319 // its implementation will assert. This situation can arise when dealing
2320 // with UTF-8 multibyte characters.
2321 if (name.empty() || (!isalpha(name[0]) && name[0] != '_
'))
2323 return llvm::all_of(name.drop_front(), [](unsigned char c) {
2324 return isalnum(c) || c == '_
' || c == '$
' || c == '.
';
2330 static void printKeywordOrString(StringRef keyword, raw_ostream &os) {
2331 // If it can be represented as a bare identifier, write it directly.
2332 if (isBareIdentifier(keyword)) {
2337 // Otherwise, output the keyword wrapped in quotes with proper escaping.
2339 printEscapedString(keyword, os);
2346 static void printSymbolReference(StringRef symbolRef, raw_ostream &os) {
2347 if (symbolRef.empty()) {
2348 os << "@<<INVALID EMPTY SYMBOL>>
";
2352 printKeywordOrString(symbolRef, os);
2355 // Print out a valid ElementsAttr that is succinct and can represent any
2356 // potential shape/type, for use when eliding a large ElementsAttr.
2358 // We choose to use a dense resource ElementsAttr literal with conspicuous
2359 // content to hopefully alert readers to the fact that this has been elided.
2360 static void printElidedElementsAttr(raw_ostream &os) {
2361 os << R"(dense_resource<__elided__>)
";
2364 void AsmPrinter::Impl::printResourceHandle(
2365 const AsmDialectResourceHandle &resource) {
2366 auto *interface = cast<OpAsmDialectInterface>(resource.getDialect());
2367 ::printKeywordOrString(interface->getResourceKey(resource), os);
2368 state.getDialectResources()[resource.getDialect()].insert(resource);
2371 LogicalResult AsmPrinter::Impl::printAlias(Attribute attr) {
2372 return state.getAliasState().getAlias(attr, os);
2375 LogicalResult AsmPrinter::Impl::printAlias(Type type) {
2376 return state.getAliasState().getAlias(type, os);
2379 void AsmPrinter::Impl::printAttribute(Attribute attr,
2380 AttrTypeElision typeElision) {
2382 os << "<<NULL ATTRIBUTE>>
";
2386 // Try to print an alias for this attribute.
2387 if (succeeded(printAlias(attr)))
2389 return printAttributeImpl(attr, typeElision);
2391 void AsmPrinter::Impl::printAttributeImpl(Attribute attr,
2392 AttrTypeElision typeElision) {
2393 if (!isa<BuiltinDialect>(attr.getDialect())) {
2394 printDialectAttribute(attr);
2395 } else if (auto opaqueAttr = llvm::dyn_cast<OpaqueAttr>(attr)) {
2396 printDialectSymbol(os, "#
", opaqueAttr.getDialectNamespace(),
2397 opaqueAttr.getAttrData());
2398 } else if (llvm::isa<UnitAttr>(attr)) {
2401 } else if (auto distinctAttr = llvm::dyn_cast<DistinctAttr>(attr)) {
2402 os << "distinct[
" << state.getDistinctState().getId(distinctAttr) << "]<
";
2403 if (!llvm::isa<UnitAttr>(distinctAttr.getReferencedAttr())) {
2404 printAttribute(distinctAttr.getReferencedAttr());
2408 } else if (auto dictAttr = llvm::dyn_cast<DictionaryAttr>(attr)) {
2410 interleaveComma(dictAttr.getValue(),
2411 [&](NamedAttribute attr) { printNamedAttribute(attr); });
2414 } else if (auto intAttr = llvm::dyn_cast<IntegerAttr>(attr)) {
2415 Type intType = intAttr.getType();
2416 if (intType.isSignlessInteger(1)) {
2417 os << (intAttr.getValue().getBoolValue() ? "true" : "false");
2419 // Boolean integer attributes always elides the type.
2423 // Only print attributes as unsigned if they are explicitly unsigned or are
2424 // signless 1-bit values. Indexes, signed values, and multi-bit signless
2425 // values print as signed.
2427 intType.isUnsignedInteger() || intType.isSignlessInteger(1);
2428 intAttr.getValue().print(os, !isUnsigned);
2430 // IntegerAttr elides the type if I64.
2431 if (typeElision == AttrTypeElision::May && intType.isSignlessInteger(64))
2434 } else if (auto floatAttr = llvm::dyn_cast<FloatAttr>(attr)) {
2435 bool printedHex = false;
2436 printFloatValue(floatAttr.getValue(), os, &printedHex);
2438 // FloatAttr elides the type if F64.
2439 if (typeElision == AttrTypeElision::May && floatAttr.getType().isF64() &&
2443 } else if (auto strAttr = llvm::dyn_cast<StringAttr>(attr)) {
2444 printEscapedString(strAttr.getValue());
2446 } else if (auto arrayAttr = llvm::dyn_cast<ArrayAttr>(attr)) {
2448 interleaveComma(arrayAttr.getValue(), [&](Attribute attr) {
2449 printAttribute(attr, AttrTypeElision::May);
2453 } else if (auto affineMapAttr = llvm::dyn_cast<AffineMapAttr>(attr)) {
2454 os << "affine_map<
";
2455 affineMapAttr.getValue().print(os);
2458 // AffineMap always elides the type.
2461 } else if (auto integerSetAttr = llvm::dyn_cast<IntegerSetAttr>(attr)) {
2462 os << "affine_set<
";
2463 integerSetAttr.getValue().print(os);
2466 // IntegerSet always elides the type.
2469 } else if (auto typeAttr = llvm::dyn_cast<TypeAttr>(attr)) {
2470 printType(typeAttr.getValue());
2472 } else if (auto refAttr = llvm::dyn_cast<SymbolRefAttr>(attr)) {
2473 printSymbolReference(refAttr.getRootReference().getValue(), os);
2474 for (FlatSymbolRefAttr nestedRef : refAttr.getNestedReferences()) {
2476 printSymbolReference(nestedRef.getValue(), os);
2479 } else if (auto intOrFpEltAttr =
2480 llvm::dyn_cast<DenseIntOrFPElementsAttr>(attr)) {
2481 if (printerFlags.shouldElideElementsAttr(intOrFpEltAttr)) {
2482 printElidedElementsAttr(os);
2485 printDenseIntOrFPElementsAttr(intOrFpEltAttr, /*allowHex=*/true);
2489 } else if (auto strEltAttr = llvm::dyn_cast<DenseStringElementsAttr>(attr)) {
2490 if (printerFlags.shouldElideElementsAttr(strEltAttr)) {
2491 printElidedElementsAttr(os);
2494 printDenseStringElementsAttr(strEltAttr);
2498 } else if (auto sparseEltAttr = llvm::dyn_cast<SparseElementsAttr>(attr)) {
2499 if (printerFlags.shouldElideElementsAttr(sparseEltAttr.getIndices()) ||
2500 printerFlags.shouldElideElementsAttr(sparseEltAttr.getValues())) {
2501 printElidedElementsAttr(os);
2504 DenseIntElementsAttr indices = sparseEltAttr.getIndices();
2505 if (indices.getNumElements() != 0) {
2506 printDenseIntOrFPElementsAttr(indices, /*allowHex=*/false);
2508 printDenseElementsAttr(sparseEltAttr.getValues(), /*allowHex=*/true);
2512 } else if (auto stridedLayoutAttr = llvm::dyn_cast<StridedLayoutAttr>(attr)) {
2513 stridedLayoutAttr.print(os);
2514 } else if (auto denseArrayAttr = llvm::dyn_cast<DenseArrayAttr>(attr)) {
2516 printType(denseArrayAttr.getElementType());
2517 if (!denseArrayAttr.empty()) {
2519 printDenseArrayAttr(denseArrayAttr);
2523 } else if (auto resourceAttr =
2524 llvm::dyn_cast<DenseResourceElementsAttr>(attr)) {
2525 os << "dense_resource<
";
2526 printResourceHandle(resourceAttr.getRawHandle());
2528 } else if (auto locAttr = llvm::dyn_cast<LocationAttr>(attr)) {
2529 printLocation(locAttr);
2531 llvm::report_fatal_error("Unknown builtin attribute
");
2533 // Don't print the type if we must elide it, or if it is a None type.
2534 if (typeElision != AttrTypeElision::Must) {
2535 if (auto typedAttr = llvm::dyn_cast<TypedAttr>(attr)) {
2536 Type attrType = typedAttr.getType();
2537 if (!llvm::isa<NoneType>(attrType)) {
2539 printType(attrType);
2546 static void printDenseIntElement(const APInt &value, raw_ostream &os,
2548 if (type.isInteger(1))
2549 os << (value.getBoolValue() ? "
true" : "false");
2551 value.print(os, !type.isUnsignedInteger());
2555 printDenseElementsAttrImpl(bool isSplat, ShapedType type, raw_ostream &os,
2556 function_ref<void(unsigned)> printEltFn) {
2557 // Special case for 0-d and splat tensors.
2559 return printEltFn(0);
2561 // Special case for degenerate tensors.
2562 auto numElements = type.getNumElements();
2563 if (numElements == 0)
2566 // We use a mixed-radix counter to iterate through the shape. When we bump a
2567 // non-least-significant digit, we emit a close bracket. When we next emit an
2568 // element we re-open all closed brackets.
2570 // The mixed-radix counter, with radices in 'shape'.
2571 int64_t rank = type.getRank();
2572 SmallVector<unsigned, 4> counter(rank, 0);
2573 // The number of brackets that have been opened and not closed.
2574 unsigned openBrackets = 0;
2576 auto shape = type.getShape();
2577 auto bumpCounter = [&] {
2578 // Bump the least significant digit.
2579 ++counter[rank - 1];
2580 // Iterate backwards bubbling back the increment.
2581 for (unsigned i = rank - 1; i > 0; --i)
2582 if (counter[i] >= shape[i]) {
2583 // Index 'i' is rolled over. Bump (i-1) and close a bracket.
2591 for (unsigned idx = 0, e = numElements; idx != e; ++idx) {
2594 while (openBrackets++ < rank)
2596 openBrackets = rank;
2600 while (openBrackets-- > 0)
2604 void AsmPrinter::Impl::printDenseElementsAttr(DenseElementsAttr attr,
2606 if (auto stringAttr = llvm::dyn_cast<DenseStringElementsAttr>(attr))
2607 return printDenseStringElementsAttr(stringAttr);
2609 printDenseIntOrFPElementsAttr(llvm::cast<DenseIntOrFPElementsAttr>(attr),
2613 void AsmPrinter::Impl::printDenseIntOrFPElementsAttr(
2614 DenseIntOrFPElementsAttr attr, bool allowHex) {
2615 auto type = attr.getType();
2616 auto elementType = type.getElementType();
2618 // Check to see if we should format this attribute as a hex string.
2619 if (allowHex && printerFlags.shouldPrintElementsAttrWithHex(attr)) {
2620 ArrayRef<char> rawData = attr.getRawData();
2621 if (llvm::endianness::native == llvm::endianness::big) {
2622 // Convert endianess in big-endian(BE) machines. `rawData` is BE in BE
2623 // machines. It is converted here to print in LE format.
2624 SmallVector<char, 64> outDataVec(rawData.size());
2625 MutableArrayRef<char> convRawData(outDataVec);
2626 DenseIntOrFPElementsAttr::convertEndianOfArrayRefForBEmachine(
2627 rawData, convRawData, type);
2628 printHexString(convRawData);
2630 printHexString(rawData);
2636 if (ComplexType complexTy = llvm::dyn_cast<ComplexType>(elementType)) {
2637 Type complexElementType = complexTy.getElementType();
2638 // Note: The if and else below had a common lambda function which invoked
2639 // printDenseElementsAttrImpl. This lambda was hitting a bug in gcc 9.1,9.2
2640 // and hence was replaced.
2641 if (llvm::isa<IntegerType>(complexElementType)) {
2642 auto valueIt = attr.value_begin<std::complex<APInt>>();
2643 printDenseElementsAttrImpl(attr.isSplat(), type, os, [&](unsigned index) {
2644 auto complexValue = *(valueIt + index);
2646 printDenseIntElement(complexValue.real(), os, complexElementType);
2648 printDenseIntElement(complexValue.imag(), os, complexElementType);
2652 auto valueIt = attr.value_begin<std::complex<APFloat>>();
2653 printDenseElementsAttrImpl(attr.isSplat(), type, os, [&](unsigned index) {
2654 auto complexValue = *(valueIt + index);
2656 printFloatValue(complexValue.real(), os);
2658 printFloatValue(complexValue.imag(), os);
2662 } else if (elementType.isIntOrIndex()) {
2663 auto valueIt = attr.value_begin<APInt>();
2664 printDenseElementsAttrImpl(attr.isSplat(), type, os, [&](unsigned index) {
2665 printDenseIntElement(*(valueIt + index), os, elementType);
2668 assert(llvm::isa<FloatType>(elementType) && "unexpected element type
");
2669 auto valueIt = attr.value_begin<APFloat>();
2670 printDenseElementsAttrImpl(attr.isSplat(), type, os, [&](unsigned index) {
2671 printFloatValue(*(valueIt + index), os);
2676 void AsmPrinter::Impl::printDenseStringElementsAttr(
2677 DenseStringElementsAttr attr) {
2678 ArrayRef<StringRef> data = attr.getRawStringData();
2679 auto printFn = [&](unsigned index) { printEscapedString(data[index]); };
2680 printDenseElementsAttrImpl(attr.isSplat(), attr.getType(), os, printFn);
2683 void AsmPrinter::Impl::printDenseArrayAttr(DenseArrayAttr attr) {
2684 Type type = attr.getElementType();
2685 unsigned bitwidth = type.isInteger(1) ? 8 : type.getIntOrFloatBitWidth();
2686 unsigned byteSize = bitwidth / 8;
2687 ArrayRef<char> data = attr.getRawData();
2689 auto printElementAt = [&](unsigned i) {
2690 APInt value(bitwidth, 0);
2692 llvm::LoadIntFromMemory(
2693 value, reinterpret_cast<const uint8_t *>(data.begin() + byteSize * i),
2696 // Print the data as-is or as a float.
2697 if (type.isIntOrIndex()) {
2698 printDenseIntElement(value, getStream(), type);
2700 APFloat fltVal(llvm::cast<FloatType>(type).getFloatSemantics(), value);
2701 printFloatValue(fltVal, getStream());
2704 llvm::interleaveComma(llvm::seq<unsigned>(0, attr.size()), getStream(),
2708 void AsmPrinter::Impl::printType(Type type) {
2710 os << "<<NULL TYPE>>
";
2714 // Try to print an alias for this type.
2715 if (succeeded(printAlias(type)))
2717 return printTypeImpl(type);
2720 void AsmPrinter::Impl::printTypeImpl(Type type) {
2721 TypeSwitch<Type>(type)
2722 .Case<OpaqueType>([&](OpaqueType opaqueTy) {
2723 printDialectSymbol(os, "!
", opaqueTy.getDialectNamespace(),
2724 opaqueTy.getTypeData());
2726 .Case<IndexType>([&](Type) { os << "index
"; })
2727 .Case<Float4E2M1FNType>([&](Type) { os << "f4E2M1FN
"; })
2728 .Case<Float6E2M3FNType>([&](Type) { os << "f6E2M3FN
"; })
2729 .Case<Float6E3M2FNType>([&](Type) { os << "f6E3M2FN
"; })
2730 .Case<Float8E5M2Type>([&](Type) { os << "f8E5M2
"; })
2731 .Case<Float8E4M3Type>([&](Type) { os << "f8E4M3
"; })
2732 .Case<Float8E4M3FNType>([&](Type) { os << "f8E4M3FN
"; })
2733 .Case<Float8E5M2FNUZType>([&](Type) { os << "f8E5M2FNUZ
"; })
2734 .Case<Float8E4M3FNUZType>([&](Type) { os << "f8E4M3FNUZ
"; })
2735 .Case<Float8E4M3B11FNUZType>([&](Type) { os << "f8E4M3B11FNUZ
"; })
2736 .Case<Float8E3M4Type>([&](Type) { os << "f8E3M4
"; })
2737 .Case<Float8E8M0FNUType>([&](Type) { os << "f8E8M0FNU
"; })
2738 .Case<BFloat16Type>([&](Type) { os << "bf16"; })
2739 .Case<Float16Type>([&](Type) { os << "f16"; })
2740 .Case<FloatTF32Type>([&](Type) { os << "tf32
"; })
2741 .Case<Float32Type>([&](Type) { os << "f32
"; })
2742 .Case<Float64Type>([&](Type) { os << "f64
"; })
2743 .Case<Float80Type>([&](Type) { os << "f80
"; })
2744 .Case<Float128Type>([&](Type) { os << "f128
"; })
2745 .Case<IntegerType>([&](IntegerType integerTy) {
2746 if (integerTy.isSigned())
2748 else if (integerTy.isUnsigned())
2750 os << 'i' << integerTy.getWidth();
2752 .Case<FunctionType>([&](FunctionType funcTy) {
2754 interleaveComma(funcTy.getInputs(), [&](Type ty) { printType(ty); });
2756 ArrayRef<Type> results = funcTy.getResults();
2757 if (results.size() == 1 && !llvm::isa<FunctionType>(results[0])) {
2758 printType(results[0]);
2761 interleaveComma(results, [&](Type ty) { printType(ty); });
2765 .Case<VectorType>([&](VectorType vectorTy) {
2766 auto scalableDims = vectorTy.getScalableDims();
2768 auto vShape = vectorTy.getShape();
2769 unsigned lastDim = vShape.size();
2770 unsigned dimIdx = 0;
2771 for (dimIdx = 0; dimIdx < lastDim; dimIdx++) {
2772 if (!scalableDims.empty() && scalableDims[dimIdx])
2774 os << vShape[dimIdx];
2775 if (!scalableDims.empty() && scalableDims[dimIdx])
2779 printType(vectorTy.getElementType());
2782 .Case<RankedTensorType>([&](RankedTensorType tensorTy) {
2784 printDimensionList(tensorTy.getShape());
2785 if (!tensorTy.getShape().empty())
2787 printType(tensorTy.getElementType());
2788 // Only print the encoding attribute value if set.
2789 if (tensorTy.getEncoding()) {
2791 printAttribute(tensorTy.getEncoding());
2795 .Case<UnrankedTensorType>([&](UnrankedTensorType tensorTy) {
2797 printType(tensorTy.getElementType());
2800 .Case<MemRefType>([&](MemRefType memrefTy) {
2802 printDimensionList(memrefTy.getShape());
2803 if (!memrefTy.getShape().empty())
2805 printType(memrefTy.getElementType());
2806 MemRefLayoutAttrInterface layout = memrefTy.getLayout();
2807 if (!llvm::isa<AffineMapAttr>(layout) || !layout.isIdentity()) {
2809 printAttribute(memrefTy.getLayout(), AttrTypeElision::May);
2811 // Only print the memory space if it is the non-default one.
2812 if (memrefTy.getMemorySpace()) {
2814 printAttribute(memrefTy.getMemorySpace(), AttrTypeElision::May);
2818 .Case<UnrankedMemRefType>([&](UnrankedMemRefType memrefTy) {
2820 printType(memrefTy.getElementType());
2821 // Only print the memory space if it is the non-default one.
2822 if (memrefTy.getMemorySpace()) {
2824 printAttribute(memrefTy.getMemorySpace(), AttrTypeElision::May);
2828 .Case<ComplexType>([&](ComplexType complexTy) {
2830 printType(complexTy.getElementType());
2833 .Case<TupleType>([&](TupleType tupleTy) {
2835 interleaveComma(tupleTy.getTypes(),
2836 [&](Type type) { printType(type); });
2839 .Case<NoneType>([&](Type) { os << "none
"; })
2840 .Default([&](Type type) { return printDialectType(type); });
2843 void AsmPrinter::Impl::printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
2844 ArrayRef<StringRef> elidedAttrs,
2846 // If there are no attributes, then there is nothing to be done.
2850 // Functor used to print a filtered attribute list.
2851 auto printFilteredAttributesFn = [&](auto filteredAttrs) {
2852 // Print the 'attributes' keyword if necessary.
2854 os << " attributes
";
2856 // Otherwise, print them all out in braces.
2858 interleaveComma(filteredAttrs,
2859 [&](NamedAttribute attr) { printNamedAttribute(attr); });
2863 // If no attributes are elided, we can directly print with no filtering.
2864 if (elidedAttrs.empty())
2865 return printFilteredAttributesFn(attrs);
2867 // Otherwise, filter out any attributes that shouldn't be included.
2868 llvm::SmallDenseSet<StringRef> elidedAttrsSet(elidedAttrs.begin(),
2870 auto filteredAttrs = llvm::make_filter_range(attrs, [&](NamedAttribute attr) {
2871 return !elidedAttrsSet.contains(attr.getName().strref());
2873 if (!filteredAttrs.empty())
2874 printFilteredAttributesFn(filteredAttrs);
2876 void AsmPrinter::Impl::printNamedAttribute(NamedAttribute attr) {
2877 // Print the name without quotes if possible.
2878 ::printKeywordOrString(attr.getName().strref(), os);
2880 // Pretty printing elides the attribute value for unit attributes.
2881 if (llvm::isa<UnitAttr>(attr.getValue()))
2885 printAttribute(attr.getValue());
2888 void AsmPrinter::Impl::printDialectAttribute(Attribute attr) {
2889 auto &dialect = attr.getDialect();
2891 // Ask the dialect to serialize the attribute to a string.
2892 std::string attrName;
2894 llvm::raw_string_ostream attrNameStr(attrName);
2895 Impl subPrinter(attrNameStr, state);
2896 DialectAsmPrinter printer(subPrinter);
2897 dialect.printAttribute(attr, printer);
2899 printDialectSymbol(os, "#
", dialect.getNamespace(), attrName);
2902 void AsmPrinter::Impl::printDialectType(Type type) {
2903 auto &dialect = type.getDialect();
2905 // Ask the dialect to serialize the type to a string.
2906 std::string typeName;
2908 llvm::raw_string_ostream typeNameStr(typeName);
2909 Impl subPrinter(typeNameStr, state);
2910 DialectAsmPrinter printer(subPrinter);
2911 dialect.printType(type, printer);
2913 printDialectSymbol(os, "!
", dialect.getNamespace(), typeName);
2916 void AsmPrinter::Impl::printEscapedString(StringRef str) {
2918 llvm::printEscapedString(str, os);
2923 os <<
"\"0x" << llvm::toHex(str) <<
"\"";
2926 printHexString(StringRef(data.data(), data.size()));
2930 return state.pushCyclicPrinting(opaquePointer);
2946 assert(
impl &&
"expected AsmPrinter::getStream to be overriden");
2947 return impl->getStream();
2952 assert(
impl &&
"expected AsmPrinter::printFloat to be overriden");
2957 assert(
impl &&
"expected AsmPrinter::printType to be overriden");
2958 impl->printType(type);
2962 assert(
impl &&
"expected AsmPrinter::printAttribute to be overriden");
2963 impl->printAttribute(attr);
2967 assert(
impl &&
"expected AsmPrinter::printAlias to be overriden");
2968 return impl->printAlias(attr);
2972 assert(
impl &&
"expected AsmPrinter::printAlias to be overriden");
2973 return impl->printAlias(type);
2978 "expected AsmPrinter::printAttributeWithoutType to be overriden");
2983 assert(
impl &&
"expected AsmPrinter::printNamedAttribute to be overriden");
2984 impl->printNamedAttribute(attr);
2988 assert(
impl &&
"expected AsmPrinter::printKeywordOrString to be overriden");
2993 assert(
impl &&
"expected AsmPrinter::printString to be overriden");
2995 printEscapedString(keyword,
getStream());
3000 assert(
impl &&
"expected AsmPrinter::printSymbolName to be overriden");
3005 assert(
impl &&
"expected AsmPrinter::printResourceHandle to be overriden");
3006 impl->printResourceHandle(resource);
3014 return impl->pushCyclicPrinting(opaquePointer);
3025 printAffineExprInternal(expr, BindingStrength::Weak, printValueName);
3031 const char *binopSpelling =
nullptr;
3034 unsigned pos = cast<AffineSymbolExpr>(expr).getPosition();
3036 printValueName(pos,
true);
3042 unsigned pos = cast<AffineDimExpr>(expr).getPosition();
3044 printValueName(pos,
false);
3050 os << cast<AffineConstantExpr>(expr).getValue();
3053 binopSpelling =
" + ";
3056 binopSpelling =
" * ";
3059 binopSpelling =
" floordiv ";
3062 binopSpelling =
" ceildiv ";
3065 binopSpelling =
" mod ";
3069 auto binOp = cast<AffineBinaryOpExpr>(expr);
3075 if (enclosingTightness == BindingStrength::Strong)
3079 auto rhsConst = dyn_cast<AffineConstantExpr>(rhsExpr);
3081 rhsConst.getValue() == -1) {
3083 printAffineExprInternal(lhsExpr, BindingStrength::Strong, printValueName);
3084 if (enclosingTightness == BindingStrength::Strong)
3089 printAffineExprInternal(lhsExpr, BindingStrength::Strong, printValueName);
3091 os << binopSpelling;
3092 printAffineExprInternal(rhsExpr, BindingStrength::Strong, printValueName);
3094 if (enclosingTightness == BindingStrength::Strong)
3100 if (enclosingTightness == BindingStrength::Strong)
3105 if (
auto rhs = dyn_cast<AffineBinaryOpExpr>(rhsExpr)) {
3108 if (
auto rrhs = dyn_cast<AffineConstantExpr>(rrhsExpr)) {
3109 if (rrhs.getValue() == -1) {
3110 printAffineExprInternal(lhsExpr, BindingStrength::Weak,
3114 printAffineExprInternal(rhs.getLHS(), BindingStrength::Strong,
3117 printAffineExprInternal(rhs.getLHS(), BindingStrength::Weak,
3121 if (enclosingTightness == BindingStrength::Strong)
3126 if (rrhs.getValue() < -1) {
3127 printAffineExprInternal(lhsExpr, BindingStrength::Weak,
3130 printAffineExprInternal(rhs.getLHS(), BindingStrength::Strong,
3132 os <<
" * " << -rrhs.getValue();
3133 if (enclosingTightness == BindingStrength::Strong)
3142 if (
auto rhsConst = dyn_cast<AffineConstantExpr>(rhsExpr)) {
3143 if (rhsConst.getValue() < 0) {
3144 printAffineExprInternal(lhsExpr, BindingStrength::Weak, printValueName);
3145 os <<
" - " << -rhsConst.getValue();
3146 if (enclosingTightness == BindingStrength::Strong)
3152 printAffineExprInternal(lhsExpr, BindingStrength::Weak, printValueName);
3155 printAffineExprInternal(rhsExpr, BindingStrength::Weak, printValueName);
3157 if (enclosingTightness == BindingStrength::Strong)
3162 printAffineExprInternal(expr, BindingStrength::Weak);
3163 isEq ? os <<
" == 0" : os <<
" >= 0";
3169 for (
int i = 0; i < (int)map.
getNumDims() - 1; ++i)
3170 os <<
'd' << i <<
", ";
3179 os <<
's' << i <<
", ";
3188 [&](
AffineExpr expr) { printAffineExpr(expr); });
3195 for (
unsigned i = 1; i < set.
getNumDims(); ++i)
3196 os <<
'd' << i - 1 <<
", ";
3205 os <<
's' << i <<
", ";
3214 for (
int i = 1; i < numConstraints; ++i) {
3218 if (numConstraints >= 1)
3219 printAffineConstraint(set.
getConstraint(numConstraints - 1),
3220 set.
isEq(numConstraints - 1));
3235 explicit OperationPrinter(raw_ostream &os,
AsmStateImpl &state)
3239 void printTopLevelOperation(
Operation *op);
3243 void printFullOpWithIndentAndLoc(
Operation *op);
3249 void printCustomOrGenericOp(
Operation *op)
override;
3251 void printGenericOp(
Operation *op,
bool printOpName)
override;
3254 void printBlockName(
Block *block);
3259 void print(
Block *block,
bool printBlockArgs =
true,
3260 bool printBlockTerminator =
true);
3263 void printValueID(
Value value,
bool printResultNo =
true,
3264 raw_ostream *streamOverride =
nullptr)
const;
3268 raw_ostream *streamOverride =
nullptr)
const;
3276 void printOptionalLocationSpecifier(
Location loc)
override {
3277 printTrailingLocation(loc);
3284 os.indent(currentIndent);
3288 void increaseIndent()
override { currentIndent += indentWidth; }
3291 void decreaseIndent()
override { currentIndent -= indentWidth; }
3300 bool omitType =
false)
override;
3303 void printOperand(
Value value)
override { printValueID(value); }
3304 void printOperand(
Value value, raw_ostream &os)
override {
3305 printValueID(value,
true, &os);
3313 void printOptionalAttrDictWithKeyword(
3321 void printSuccessor(
Block *successor)
override;
3325 void printSuccessorAndUseList(
Block *successor,
3330 bool printBlockTerminators,
bool printEmptyBlock)
override;
3337 state.getSSANameState().shadowRegionArgs(region, namesToUse);
3342 void printAffineMapOfSSAIds(AffineMapAttr mapAttr,
3357 void printValueUsers(
Value value);
3361 void printUserIDs(
Operation *user,
bool prefixComma =
false);
3369 using PrintFn =
function_ref<void(StringRef, ValueFn)>;
3371 ResourceBuilder(PrintFn printFn) : printFn(printFn) {}
3372 ~ResourceBuilder()
override =
default;
3374 void buildBool(StringRef key,
bool data)
final {
3375 printFn(key, [&](raw_ostream &os) { os << (data ?
"true" :
"false"); });
3378 void buildString(StringRef key, StringRef data)
final {
3379 printFn(key, [&](raw_ostream &os) {
3381 llvm::printEscapedString(data, os);
3387 uint32_t dataAlignment)
final {
3388 printFn(key, [&](raw_ostream &os) {
3390 llvm::support::ulittle32_t dataAlignmentLE(dataAlignment);
3392 << llvm::toHex(StringRef(
reinterpret_cast<char *
>(&dataAlignmentLE),
3393 sizeof(dataAlignment)))
3394 << llvm::toHex(StringRef(data.data(), data.size())) <<
"\"";
3403 void printFileMetadataDictionary(
Operation *op);
3409 void printResourceFileMetadata(
function_ref<
void()> checkAddMetadataDict,
3420 const static unsigned indentWidth = 2;
3423 unsigned currentIndent = 0;
3427 void OperationPrinter::printTopLevelOperation(
Operation *op) {
3429 state.getAliasState().printNonDeferredAliases(*
this, newLine);
3432 printFullOpWithIndentAndLoc(op);
3436 state.getAliasState().printDeferredAliases(*
this, newLine);
3439 printFileMetadataDictionary(op);
3442 void OperationPrinter::printFileMetadataDictionary(
Operation *op) {
3443 bool sawMetadataEntry =
false;
3444 auto checkAddMetadataDict = [&] {
3445 if (!std::exchange(sawMetadataEntry,
true))
3446 os << newLine <<
"{-#" << newLine;
3450 printResourceFileMetadata(checkAddMetadataDict, op);
3453 if (sawMetadataEntry)
3454 os << newLine <<
"#-}" << newLine;
3457 void OperationPrinter::printResourceFileMetadata(
3460 bool hadResource =
false;
3461 bool needResourceComma =
false;
3462 bool needEntryComma =
false;
3463 auto processProvider = [&](StringRef dictName, StringRef name,
auto &provider,
3464 auto &&...providerArgs) {
3465 bool hadEntry =
false;
3466 auto printFn = [&](StringRef key, ResourceBuilder::ValueFn valueFn) {
3467 checkAddMetadataDict();
3469 std::string resourceStr;
3470 auto printResourceStr = [&](raw_ostream &os) { os << resourceStr; };
3471 std::optional<uint64_t> charLimit =
3473 if (charLimit.has_value()) {
3475 if (charLimit.value() == 0)
3478 llvm::raw_string_ostream ss(resourceStr);
3482 if (resourceStr.size() > charLimit.value())
3486 valueFn = printResourceStr;
3490 if (!std::exchange(hadResource,
true)) {
3491 if (needResourceComma)
3492 os <<
"," << newLine;
3493 os <<
" " << dictName <<
"_resources: {" << newLine;
3496 if (!std::exchange(hadEntry,
true)) {
3498 os <<
"," << newLine;
3499 os <<
" " << name <<
": {" << newLine;
3501 os <<
"," << newLine;
3509 ResourceBuilder entryBuilder(printFn);
3510 provider.buildResources(op, providerArgs..., entryBuilder);
3512 needEntryComma |= hadEntry;
3514 os << newLine <<
" }";
3520 auto &dialectResources = state.getDialectResources();
3521 StringRef name = interface.getDialect()->getNamespace();
3522 auto it = dialectResources.find(interface.getDialect());
3523 if (it != dialectResources.end())
3524 processProvider(
"dialect", name, interface, it->second);
3526 processProvider(
"dialect", name, interface,
3530 os << newLine <<
" }";
3534 needEntryComma =
false;
3535 needResourceComma = hadResource;
3536 hadResource =
false;
3537 for (
const auto &printer : state.getResourcePrinters())
3538 processProvider(
"external", printer.getName(), printer);
3540 os << newLine <<
" }";
3548 void OperationPrinter::printRegionArgument(
BlockArgument arg,
3556 printOptionalAttrDict(argAttrs);
3558 printTrailingLocation(arg.
getLoc(),
false);
3561 void OperationPrinter::printFullOpWithIndentAndLoc(
Operation *op) {
3563 state.registerOperationLocation(op, newLine.curLine, currentIndent);
3565 os.indent(currentIndent);
3567 printTrailingLocation(op->
getLoc());
3569 printUsersComment(op);
3572 void OperationPrinter::printFullOp(
Operation *op) {
3574 auto printResultGroup = [&](
size_t resultNo,
size_t resultCount) {
3575 printValueID(op->
getResult(resultNo),
false);
3576 if (resultCount > 1)
3577 os <<
':' << resultCount;
3581 ArrayRef<int> resultGroups = state.getSSANameState().getOpResultGroups(op);
3582 if (!resultGroups.empty()) {
3585 interleaveComma(llvm::seq<int>(0, resultGroups.size() - 1), [&](
int i) {
3586 printResultGroup(resultGroups[i],
3587 resultGroups[i + 1] - resultGroups[i]);
3590 printResultGroup(resultGroups.back(), numResults - resultGroups.back());
3593 printResultGroup(0, numResults);
3599 printCustomOrGenericOp(op);
3602 void OperationPrinter::printUsersComment(
Operation *op) {
3606 printOperationID(op);
3607 }
else if (numResults && op->
use_empty()) {
3609 }
else if (numResults && !op->
use_empty()) {
3612 unsigned usedInNResults = 0;
3613 unsigned usedInNOperations = 0;
3616 if (userSet.insert(user).second) {
3617 ++usedInNOperations;
3618 usedInNResults += user->getNumResults();
3623 bool exactlyOneUniqueUse =
3624 usedInNResults <= 1 && usedInNOperations <= 1 && numResults == 1;
3625 os <<
" // " << (exactlyOneUniqueUse ?
"user" :
"users") <<
": ";
3626 bool shouldPrintBrackets = numResults > 1;
3627 auto printOpResult = [&](
OpResult opResult) {
3628 if (shouldPrintBrackets)
3630 printValueUsers(opResult);
3631 if (shouldPrintBrackets)
3635 interleaveComma(op->
getResults(), printOpResult);
3639 void OperationPrinter::printUsersComment(
BlockArgument arg) {
3645 os <<
" is used by ";
3646 printValueUsers(arg);
3651 void OperationPrinter::printValueUsers(
Value value) {
3659 if (userSet.insert(user).second)
3660 printUserIDs(user, index);
3664 void OperationPrinter::printUserIDs(
Operation *user,
bool prefixComma) {
3669 printOperationID(user);
3672 [
this](
Value result) { printValueID(result); });
3676 void OperationPrinter::printCustomOrGenericOp(
Operation *op) {
3682 opInfo->printAssembly(op, *
this, defaultDialectStack.back());
3687 if (
auto opPrinter = dialect->getOperationPrinter(op)) {
3692 if (name.count(
'.') == 1)
3693 name.consume_front((defaultDialectStack.back() +
".").str());
3697 opPrinter(op, *
this);
3704 printGenericOp(op,
true);
3707 void OperationPrinter::printGenericOp(
Operation *op,
bool printOpName) {
3711 interleaveComma(op->
getOperands(), [&](
Value value) { printValueID(value); });
3718 [&](
Block *successor) { printBlockName(successor); });
3730 if (op->getNumRegions() != 0) {
3732 interleaveComma(op->getRegions(), [&](Region ®ion) {
3733 printRegion(region, /*printEntryBlockArgs=*/true,
3734 /*printBlockTerminators=*/true, /*printEmptyBlock=*/true);
3739 printOptionalAttrDict(op->getPropertiesStorage()
3740 ? llvm::to_vector(op->getDiscardableAttrs())
3743 // Print the type signature of the operation.
3745 printFunctionalType(op);
3748 void OperationPrinter::printBlockName(Block *block) {
3749 os << state.getSSANameState().getBlockInfo(block).name;
3752 void OperationPrinter::print(Block *block, bool printBlockArgs,
3753 bool printBlockTerminator) {
3754 // Print the block label and argument list if requested.
3755 if (printBlockArgs) {
3756 os.indent(currentIndent);
3757 printBlockName(block);
3759 // Print the argument list if non-empty.
3760 if (!block->args_empty()) {
3762 interleaveComma(block->getArguments(), [&](BlockArgument arg) {
3765 printType(arg.getType());
3766 // TODO: We should allow location aliases on block arguments.
3767 printTrailingLocation(arg.getLoc(), /*allowAlias*/ false);
3773 // Print out some context information about the predecessors of this block.
3774 if (!block->getParent()) {
3775 os << " // block is not in a region!";
3776 } else if (block->hasNoPredecessors()) {
3777 if (!block->isEntryBlock())
3778 os << " // no predecessors";
3779 } else if (auto *pred = block->getSinglePredecessor()) {
3781 printBlockName(pred);
3783 // We want to print the predecessors in a stable order, not in
3784 // whatever order the use-list is in, so gather and sort them.
3785 SmallVector<BlockInfo, 4> predIDs;
3786 for (auto *pred : block->getPredecessors())
3787 predIDs.push_back(state.getSSANameState().getBlockInfo(pred));
3788 llvm::sort(predIDs, [](BlockInfo lhs, BlockInfo rhs) {
3789 return lhs.ordering < rhs.ordering;
3792 os << " // " << predIDs.size() << " preds: ";
3794 interleaveComma(predIDs, [&](BlockInfo pred) { os << pred.name; });
3799 currentIndent += indentWidth;
3801 if (printerFlags.shouldPrintValueUsers()) {
3802 for (BlockArgument arg : block->getArguments()) {
3803 os.indent(currentIndent);
3804 printUsersComment(arg);
3808 bool hasTerminator =
3809 !block->empty() && block->back().hasTrait<OpTrait::IsTerminator>();
3810 auto range = llvm::make_range(
3812 std::prev(block->end(),
3813 (!hasTerminator || printBlockTerminator) ? 0 : 1));
3814 for (auto &op : range) {
3815 printFullOpWithIndentAndLoc(&op);
3818 currentIndent -= indentWidth;
3821 void OperationPrinter::printValueID(Value value, bool printResultNo,
3822 raw_ostream *streamOverride) const {
3823 state.getSSANameState().printValueID(value, printResultNo,
3824 streamOverride ? *streamOverride : os);
3827 void OperationPrinter::printOperationID(Operation *op,
3828 raw_ostream *streamOverride) const {
3829 state.getSSANameState().printOperationID(op, streamOverride ? *streamOverride
3833 void OperationPrinter::printSuccessor(Block *successor) {
3834 printBlockName(successor);
3837 void OperationPrinter::printSuccessorAndUseList(Block *successor,
3838 ValueRange succOperands) {
3839 printBlockName(successor);
3840 if (succOperands.empty())
3844 interleaveComma(succOperands,
3845 [this](Value operand) { printValueID(operand); });
3847 interleaveComma(succOperands,
3848 [this](Value operand) { printType(operand.getType()); });
3852 void OperationPrinter::printRegion(Region ®ion, bool printEntryBlockArgs,
3853 bool printBlockTerminators,
3854 bool printEmptyBlock) {
3855 if (printerFlags.shouldSkipRegions()) {
3859 os << "{" << newLine;
3860 if (!region.empty()) {
3861 auto restoreDefaultDialect =
3862 llvm::make_scope_exit([&]() { defaultDialectStack.pop_back(); });
3863 if (auto iface = dyn_cast<OpAsmOpInterface>(region.getParentOp()))
3864 defaultDialectStack.push_back(iface.getDefaultDialect());
3866 defaultDialectStack.push_back("");
3868 auto *entryBlock = ®ion.front();
3869 // Force printing the block header if printEmptyBlock is set and the block
3870 // is empty or if printEntryBlockArgs is set and there are arguments to
3872 bool shouldAlwaysPrintBlockHeader =
3873 (printEmptyBlock && entryBlock->empty()) ||
3874 (printEntryBlockArgs && entryBlock->getNumArguments() != 0);
3875 print(entryBlock, shouldAlwaysPrintBlockHeader, printBlockTerminators);
3876 for (auto &b : llvm::drop_begin(region.getBlocks(), 1))
3879 os.indent(currentIndent) << "}";
3882 void OperationPrinter::printAffineMapOfSSAIds(AffineMapAttr mapAttr,
3883 ValueRange operands) {
3885 os << "<<NULL AFFINE MAP>>";
3888 AffineMap map = mapAttr.getValue();
3889 unsigned numDims = map.getNumDims();
3890 auto printValueName = [&](unsigned pos, bool isSymbol) {
3891 unsigned index = isSymbol ? numDims + pos : pos;
3892 assert(index < operands.size());
3895 printValueID(operands[index]);
3900 interleaveComma(map.getResults(), [&](AffineExpr expr) {
3901 printAffineExpr(expr, printValueName);
3905 void OperationPrinter::printAffineExprOfSSAIds(AffineExpr expr,
3906 ValueRange dimOperands,
3907 ValueRange symOperands) {
3908 auto printValueName = [&](unsigned pos, bool isSymbol) {
3910 return printValueID(dimOperands[pos]);
3912 printValueID(symOperands[pos]);
3915 printAffineExpr(expr, printValueName);
3918 //===----------------------------------------------------------------------===//
3919 // print and dump methods
3920 //===----------------------------------------------------------------------===//
3922 void Attribute::print(raw_ostream &os, bool elideType) const {
3924 os << "<<NULL ATTRIBUTE>>";
3928 AsmState state(getContext());
3929 print(os, state, elideType);
3931 void Attribute::print(raw_ostream &os, AsmState &state, bool elideType) const {
3932 using AttrTypeElision = AsmPrinter::Impl::AttrTypeElision;
3933 AsmPrinter::Impl(os, state.getImpl())
3934 .printAttribute(*this, elideType ? AttrTypeElision::Must
3935 : AttrTypeElision::Never);
3938 void Attribute::dump() const {
3939 print(llvm::errs());
3940 llvm::errs() << "\n";
3943 void Attribute::printStripped(raw_ostream &os, AsmState &state) const {
3945 os << "<<NULL ATTRIBUTE>>";
3949 AsmPrinter::Impl subPrinter(os, state.getImpl());
3950 if (succeeded(subPrinter.printAlias(*this)))
3953 auto &dialect = this->getDialect();
3954 uint64_t posPrior = os.tell();
3955 DialectAsmPrinter printer(subPrinter);
3956 dialect.printAttribute(*this, printer);
3957 if (posPrior != os.tell())
3960 // Fallback to printing with prefix if the above failed to write anything
3961 // to the output stream.
3964 void Attribute::printStripped(raw_ostream &os) const {
3966 os << "<<NULL ATTRIBUTE>>";
3970 AsmState state(getContext());
3971 printStripped(os, state);
3974 void Type::print(raw_ostream &os) const {
3976 os << "<<NULL TYPE>>";
3980 AsmState state(getContext());
3983 void Type::print(raw_ostream &os, AsmState &state) const {
3984 AsmPrinter::Impl(os, state.getImpl()).printType(*this);
3987 void Type::dump() const {
3988 print(llvm::errs());
3989 llvm::errs() << "\n";
3992 void AffineMap::dump() const {
3993 print(llvm::errs());
3994 llvm::errs() << "\n";
3997 void IntegerSet::dump() const {
3998 print(llvm::errs());
3999 llvm::errs() << "\n";
4002 void AffineExpr::print(raw_ostream &os) const {
4004 os << "<<NULL AFFINE EXPR>>";
4007 AsmState state(getContext());
4008 AsmPrinter::Impl(os, state.getImpl()).printAffineExpr(*this);
4011 void AffineExpr::dump() const {
4012 print(llvm::errs());
4013 llvm::errs() << "\n";
4016 void AffineMap::print(raw_ostream &os) const {
4018 os << "<<NULL AFFINE MAP>>";
4021 AsmState state(getContext());
4022 AsmPrinter::Impl(os, state.getImpl()).printAffineMap(*this);
4025 void IntegerSet::print(raw_ostream &os) const {
4026 AsmState state(getContext());
4027 AsmPrinter::Impl(os, state.getImpl()).printIntegerSet(*this);
4030 void Value::print(raw_ostream &os) const { print(os, OpPrintingFlags()); }
4031 void Value::print(raw_ostream &os, const OpPrintingFlags &flags) const {
4033 os << "<<NULL VALUE>>";
4037 if (auto *op = getDefiningOp())
4038 return op->print(os, flags);
4039 // TODO: Improve BlockArgument print'ing.
4041 os <<
"<block argument> of type '" << arg.
getType()
4046 os <<
"<<NULL VALUE>>";
4050 if (
auto *op = getDefiningOp())
4051 return op->
print(os, state);
4055 os <<
"<block argument> of type '" << arg.
getType()
4060 print(llvm::errs());
4061 llvm::errs() <<
"\n";
4069 state.getImpl().getSSANameState().printValueID(*
this,
true,
4092 if (
auto result = llvm::dyn_cast<OpResult>(*
this)) {
4095 op = llvm::cast<BlockArgument>(*this).getOwner()->
getParentOp();
4097 os <<
"<<UNKNOWN SSA VALUE>>";
4103 printAsOperand(os, state);
4113 OperationPrinter printer(os, state.getImpl());
4114 if (!getParent() && !state.getPrinterFlags().shouldUseLocalScope()) {
4115 state.getImpl().initializeAliases(
this);
4116 printer.printTopLevelOperation(
this);
4118 printer.printFullOpWithIndentAndLoc(
this);
4124 llvm::errs() <<
"\n";
4129 llvm::errs() <<
"\n";
4135 os <<
"<<UNLINKED BLOCK>>\n";
4146 OperationPrinter(os, state.getImpl()).print(
this);
4155 os <<
"<<UNLINKED BLOCK>>\n";
4159 printAsOperand(os, state);
4162 OperationPrinter printer(os, state.getImpl());
4163 printer.printBlockName(
this);
4178 if (dimensions.empty())
4181 if (dimensions.empty())
4191 <<
"Failed parsing dimension list.";
4202 <<
"Failed parsing dimension list.";
4204 if (shapeArr.empty()) {
4206 <<
"Failed parsing dimension list. Did you mean an empty list? It "
4207 "must be denoted by \"[]\".";
static void printSymbolReference(StringRef symbolRef, raw_ostream &os)
Print the given string as a symbol reference.
static void printFloatValue(const APFloat &apValue, raw_ostream &os, bool *printedHex=nullptr)
Print a floating point value in a way that the parser will be able to round-trip losslessly.
static StringRef sanitizeIdentifier(StringRef name, SmallString< 16 > &buffer, StringRef allowedPunctChars="$._-")
Sanitize the given name such that it can be used as a valid identifier.
static llvm::ManagedStatic< AsmPrinterOptions > clOptions
static Operation * findParent(Operation *op, bool shouldUseLocalScope)
static void printKeywordOrString(StringRef keyword, raw_ostream &os)
Print the given string as a keyword, or a quoted and escaped string if it has any special or non-prin...
static bool isDialectSymbolSimpleEnoughForPrettyForm(StringRef symName)
Returns true if the given dialect symbol data is simple enough to print in the pretty form.
static void printDialectSymbol(raw_ostream &os, StringRef symPrefix, StringRef dialectName, StringRef symString)
Print the given dialect symbol to the stream.
static OpPrintingFlags verifyOpAndAdjustFlags(Operation *op, OpPrintingFlags printerFlags)
Verifies the operation and switches to generic op printing if verification fails.
MLIR_CRUNNERUTILS_EXPORT void printString(char const *s)
MLIR_CRUNNERUTILS_EXPORT void printNewline()
static void visit(Operation *op, DenseSet< Operation * > &visited)
Visits all the pdl.operand(s), pdl.result(s), and pdl.operation(s) connected to the given operation.
static MLIRContext * getContext(OpFoldResult val)
union mlir::linalg::@1216::ArityGroupAndKind::Kind kind
static std::string diag(const llvm::Value &value)
static void print(spirv::VerCapExtAttr triple, DialectAsmPrinter &printer)
static void printRegion(llvm::raw_ostream &os, Region *region, OpPrintingFlags &flags)
Base type for affine expression.
AffineExprKind getKind() const
Return the classification for this type.
A multi-dimensional affine map Affine map's are immutable like Type's, and they are uniqued.
unsigned getNumSymbols() const
unsigned getNumDims() const
ArrayRef< AffineExpr > getResults() const
This class represents an opaque handle to a dialect resource entry.
This class represents a single parsed resource entry.
virtual FailureOr< AsmResourceBlob > parseAsBlob(BlobAllocatorFn allocator) const =0
Parse the resource entry represented by a binary blob.
virtual InFlightDiagnostic emitError() const =0
Emit an error at the location of this entry.
virtual AsmResourceEntryKind getKind() const =0
Return the kind of this value.
virtual FailureOr< std::string > parseAsString() const =0
Parse the resource entry represented by a human-readable string.
virtual FailureOr< bool > parseAsBool() const =0
Parse the resource entry represented by a boolean.
virtual StringRef getKey() const =0
Return the key of the resource entry.
MLIRContext * getContext() const
virtual InFlightDiagnostic emitError(SMLoc loc, const Twine &message={})=0
Emit a diagnostic at the specified location and return failure.
virtual ParseResult parseRSquare()=0
Parse a ] token.
virtual ParseResult parseDimensionList(SmallVectorImpl< int64_t > &dimensions, bool allowDynamic=true, bool withTrailingX=true)=0
Parse a dimension list of a tensor or memref type.
virtual SMLoc getCurrentLocation()=0
Get the location of the next token and store it into the argument.
ParseResult parseTypeList(SmallVectorImpl< Type > &result)
Parse a type list.
virtual ParseResult parseOptionalLSquare()=0
Parse a [ token if present.
Impl(raw_ostream &os, AsmStateImpl &state)
BindingStrength
This enum is used to represent the binding strength of the enclosing context that an AffineExprStorag...
void printHexString(StringRef str)
Print a hex string, wrapped with "".
void printDenseArrayAttr(DenseArrayAttr attr)
Print a dense array attribute.
void printDenseElementsAttr(DenseElementsAttr attr, bool allowHex)
Print a dense elements attribute.
void printAttribute(Attribute attr, AttrTypeElision typeElision=AttrTypeElision::Never)
Print the given attribute or an alias.
void printDimensionList(ArrayRef< int64_t > shape)
OpPrintingFlags printerFlags
A set of flags to control the printer's behavior.
raw_ostream & os
The output stream for the printer.
void printResourceHandle(const AsmDialectResourceHandle &resource)
Print a reference to the given resource that is owned by the given dialect.
raw_ostream & getStream()
Returns the output stream of the printer.
LogicalResult printAlias(Attribute attr)
Print the alias for the given attribute, return failure if no alias could be printed.
void printDialectAttribute(Attribute attr)
void interleaveComma(const Container &c, UnaryFunctor eachFn) const
void printDialectType(Type type)
void printLocation(LocationAttr loc, bool allowAlias=false)
Print the given location to the stream.
AsmStateImpl & state
An underlying assembly printer state.
void printAffineMap(AffineMap map)
void printTrailingLocation(Location loc, bool allowAlias=true)
void printAffineExprInternal(AffineExpr expr, BindingStrength enclosingTightness, function_ref< void(unsigned, bool)> printValueName=nullptr)
void printEscapedString(StringRef str)
Print an escaped string, wrapped with "".
void printAffineExpr(AffineExpr expr, function_ref< void(unsigned, bool)> printValueName=nullptr)
void printDenseStringElementsAttr(DenseStringElementsAttr attr)
Print a dense string elements attribute.
void printAttributeImpl(Attribute attr, AttrTypeElision typeElision=AttrTypeElision::Never)
Print the given attribute without considering an alias.
void printAffineConstraint(AffineExpr expr, bool isEq)
void printDenseIntOrFPElementsAttr(DenseIntOrFPElementsAttr attr, bool allowHex)
Print a dense elements attribute.
AttrTypeElision
This enum describes the different kinds of elision for the type of an attribute when printing it.
@ May
The type may be elided when it matches the default used in the parser (for example i64 is the default...
@ Never
The type must not be elided,.
@ Must
The type must be elided.
LogicalResult pushCyclicPrinting(const void *opaquePointer)
void printIntegerSet(IntegerSet set)
NewLineCounter newLine
A tracker for the number of new lines emitted during printing.
void printOptionalAttrDict(ArrayRef< NamedAttribute > attrs, ArrayRef< StringRef > elidedAttrs={}, bool withKeyword=false)
void printType(Type type)
Print the given type or an alias.
void printLocationInternal(LocationAttr loc, bool pretty=false, bool isTopLevel=false)
void printTypeImpl(Type type)
Print the given type.
void printNamedAttribute(NamedAttribute attr)
virtual void printAttributeWithoutType(Attribute attr)
Print the given attribute without its type.
virtual LogicalResult printAlias(Attribute attr)
Print the alias for the given attribute, return failure if no alias could be printed.
virtual void popCyclicPrinting()
Removes the element that was last inserted with a successful call to pushCyclicPrinting.
virtual LogicalResult pushCyclicPrinting(const void *opaquePointer)
Pushes a new attribute or type in the form of a type erased pointer into an internal set.
virtual void printType(Type type)
virtual void printKeywordOrString(StringRef keyword)
Print the given string as a keyword, or a quoted and escaped string if it has any special or non-prin...
virtual void printSymbolName(StringRef symbolRef)
Print the given string as a symbol reference, i.e.
virtual void printString(StringRef string)
Print the given string as a quoted string, escaping any special or non-printable characters in it.
virtual void printAttribute(Attribute attr)
void printDimensionList(ArrayRef< int64_t > shape)
virtual raw_ostream & getStream() const
Return the raw output stream used by this printer.
virtual void printResourceHandle(const AsmDialectResourceHandle &resource)
Print a handle to the given dialect resource.
virtual void printFloat(const APFloat &value)
Print the given floating point value in a stabilized form that can be roundtripped through the IR.
virtual void printNamedAttribute(NamedAttribute attr)
Print the given named attribute.
This class is used to build resource entries for use by the printer.
virtual void buildString(StringRef key, StringRef data)=0
Build a resource entry represented by the given human-readable string value.
virtual void buildBool(StringRef key, bool data)=0
Build a resource entry represented by the given bool.
virtual void buildBlob(StringRef key, ArrayRef< char > data, uint32_t dataAlignment)=0
Build an resource entry represented by the given binary blob data.
This class represents an instance of a resource parser.
static std::unique_ptr< AsmResourcePrinter > fromCallable(StringRef name, CallableT &&printFn)
Return a resource printer implemented via the given callable, whose form should match that of buildRe...
This class provides management for the lifetime of the state used when printing the IR.
void attachResourcePrinter(std::unique_ptr< AsmResourcePrinter > printer)
Attach the given resource printer to the AsmState.
DenseMap< Dialect *, SetVector< AsmDialectResourceHandle > > & getDialectResources() const
Returns a map of dialect resources that were referenced when using this state to print IR.
void attachFallbackResourcePrinter(FallbackAsmResourceMap &map)
Attach resource printers to the AsmState for the fallback resources in the given map.
const OpPrintingFlags & getPrinterFlags() const
Get the printer flags.
Attributes are known-constant values of operations.
Dialect & getDialect() const
Get the dialect this attribute is registered to.
bool hasTrait()
Returns true if the type was registered with a particular trait.
const void * getAsOpaquePointer() const
Get an opaque pointer to the attribute.
static Attribute getFromOpaquePointer(const void *ptr)
Construct an attribute from the opaque pointer representation.
This class represents an argument of a Block.
Location getLoc() const
Return the location for this argument.
unsigned getArgNumber() const
Returns the number of this argument.
Block represents an ordered list of Operations.
void printAsOperand(raw_ostream &os, bool printType=true)
Print out the name of the block without printing its body.
void print(raw_ostream &os)
BlockArgListType getArguments()
bool isEntryBlock()
Return if this block is the entry block in the parent region.
Operation * getParentOp()
Returns the closest surrounding operation that contains this block.
An attribute that represents a reference to a dense vector or tensor object.
This class contains all of the information necessary to report a diagnostic to the DiagnosticEngine.
~DialectAsmParser() override
This is a pure-virtual base class that exposes the asmprinter hooks necessary to implement a custom p...
~DialectAsmPrinter() override
A collection of dialect interfaces within a context, for a given concrete interface type.
Dialects are groups of MLIR operations, types and attributes, as well as behavior associated with the...
virtual void printAttribute(Attribute, DialectAsmPrinter &) const
Print an attribute registered to this dialect.
virtual void printType(Type, DialectAsmPrinter &) const
Print a type registered to this dialect.
An attribute that associates a referenced attribute with a unique identifier.
A fallback map containing external resources not explicitly handled by another parser/printer.
std::vector< std::unique_ptr< AsmResourcePrinter > > getPrinters()
Build a set of resource printers to print the resources within this map.
An integer set representing a conjunction of one or more affine equalities and inequalities.
unsigned getNumDims() const
unsigned getNumConstraints() const
AffineExpr getConstraint(unsigned idx) const
bool isEq(unsigned idx) const
Returns true if the idx^th constraint is an equality, false if it is an inequality.
unsigned getNumSymbols() const
Location objects represent source locations information in MLIR.
T findInstanceOf()
Return an instance of the given location type if one is nested under the current location.
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
MLIRContext is the top-level object for a collection of MLIR operations.
NamedAttribute represents a combination of a name and an Attribute value.
Attribute getValue() const
Return the value of the attribute.
virtual LogicalResult parseResource(AsmParsedResourceEntry &entry) const
Hook for parsing resource entries.
The OpAsmParser has methods for interacting with the asm parser: parsing things from it,...
This is a pure-virtual base class that exposes the asmprinter hooks necessary to implement a custom p...
void printFunctionalType(Operation *op)
Print the complete type of an operation in functional form.
Set of flags used to control the behavior of the various IR print methods (e.g.
bool shouldElideElementsAttr(ElementsAttr attr) const
Return if the given ElementsAttr should be elided.
std::optional< int64_t > getLargeElementsAttrLimit() const
Return the size limit for printing large ElementsAttr.
bool shouldUseNameLocAsPrefix() const
Return if the printer should use NameLocs as prefixes when printing SSA IDs.
bool shouldAssumeVerified() const
Return if operation verification should be skipped.
OpPrintingFlags & printLargeElementsAttrWithHex(int64_t largeElementLimit=100)
Enables the printing of large element attributes with a hex string.
bool shouldUseLocalScope() const
Return if the printer should use local scope when dumping the IR.
bool shouldPrintDebugInfoPrettyForm() const
Return if debug information should be printed in the pretty form.
bool shouldPrintElementsAttrWithHex(ElementsAttr attr) const
Return if the given ElementsAttr should be printed as hex string.
bool shouldPrintUniqueSSAIDs() const
Return if printer should use unique SSA IDs.
bool shouldPrintValueUsers() const
Return if the printer should print users of values.
int64_t getLargeElementsAttrHexLimit() const
Return the size limit for printing large ElementsAttr as hex string.
bool shouldPrintGenericOpForm() const
Return if operations should be printed in the generic form.
OpPrintingFlags & elideLargeResourceString(int64_t largeResourceLimit=64)
Enables the elision of large resources strings by omitting them from the dialect_resources section.
bool shouldPrintDebugInfo() const
Return if debug information should be printed.
OpPrintingFlags & elideLargeElementsAttrs(int64_t largeElementLimit=16)
Enables the elision of large elements attributes by printing a lexically valid but otherwise meaningl...
OpPrintingFlags & printNameLocAsPrefix(bool enable=true)
Print SSA IDs using their NameLoc, if provided, as prefix.
OpPrintingFlags & printValueUsers(bool enable=true)
Print users of values as comments.
OpPrintingFlags & enableDebugInfo(bool enable=true, bool prettyForm=false)
Enable or disable printing of debug information (based on enable).
OpPrintingFlags()
Initialize the printing flags with default supplied by the cl::opts above.
bool shouldSkipRegions() const
Return if regions should be skipped.
OpPrintingFlags & printGenericOpForm(bool enable=true)
Always print operations in the generic form.
OpPrintingFlags & useLocalScope(bool enable=true)
Use local scope when printing the operation.
std::optional< uint64_t > getLargeResourceStringLimit() const
Return the size limit in chars for printing large resources.
OpPrintingFlags & assumeVerified(bool enable=true)
Do not verify the operation when using custom operation printers.
OpPrintingFlags & skipRegions(bool skip=true)
Skip printing regions.
OpPrintingFlags & printUniqueSSAIDs(bool enable=true)
Print unique SSA ID numbers for values, block arguments and naming conflicts across all regions.
This is a value defined by a result of an operation.
Operation * getOwner() const
Returns the operation that owns this result.
unsigned getResultNumber() const
Returns the number of this result.
This class provides the API for ops that are known to be isolated from above.
This class provides the API for ops that are known to be terminators.
StringRef getStringRef() const
Return the name of this operation. This always succeeds.
void printAssembly(Operation *op, OpAsmPrinter &p, StringRef defaultDialect) const
This hook implements the AsmPrinter for this operation.
void print(raw_ostream &os) const
Operation is the basic unit of execution within MLIR.
bool use_empty()
Returns true if this operation has no uses.
bool hasTrait()
Returns true if the operation was registered with a particular trait, e.g.
Dialect * getDialect()
Return the dialect this operation is associated with, or nullptr if the associated dialect is not loa...
unsigned getNumSuccessors()
OpResult getResult(unsigned idx)
Get the 'idx'th result of this operation.
void print(raw_ostream &os, const OpPrintingFlags &flags=std::nullopt)
MLIRContext * getContext()
Return the context this operation is associated with.
std::optional< RegisteredOperationName > getRegisteredInfo()
If this operation has a registered operation description, return it.
Location getLoc()
The source location the operation was defined or derived from.
unsigned getNumOperands()
Attribute getPropertiesAsAttribute()
Return the properties converted to an attribute.
Operation * getParentOp()
Returns the closest surrounding operation that contains this operation or nullptr if this is a top-le...
ArrayRef< NamedAttribute > getAttrs()
Return all of the attributes on this operation.
MutableArrayRef< Region > getRegions()
Returns the regions held by this operation.
OperationName getName()
The name of an operation is the key identifier for it.
operand_type_range getOperandTypes()
result_type_range getResultTypes()
LLVM_DUMP_METHOD void dumpPretty()
operand_range getOperands()
Returns an iterator on the underlying Value's.
user_range getUsers()
Returns a range of all users.
SuccessorRange getSuccessors()
result_range getResults()
unsigned getNumResults()
Return the number of results held by this operation.
This class contains a list of basic blocks and a link to the parent operation it is attached to.
iterator_range< OpIterator > getOps()
BlockArgListType getArguments()
Operation * getParentOp()
Return the parent operation this region is attached to.
unsigned getNumArguments()
BlockArgument getArgument(unsigned i)
This diagnostic handler is a simple RAII class that registers and erases a diagnostic handler on a gi...
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
const void * getAsOpaquePointer() const
Methods for supporting PointerLikeTypeTraits.
Dialect & getDialect() const
Get the dialect this type is registered to.
static Type getFromOpaquePointer(const void *pointer)
void walkImmediateSubElements(function_ref< void(Attribute)> walkAttrsFn, function_ref< void(Type)> walkTypesFn) const
Walk all of the immediately nested sub-attributes and sub-types.
This class provides an abstraction over the different types of ranges over Values.
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
bool use_empty() const
Returns true if this value has no uses.
void print(raw_ostream &os) const
Type getType() const
Return the type of this value.
void printAsOperand(raw_ostream &os, AsmState &state) const
Print this value as if it were an operand.
user_range getUsers() const
Location getLoc() const
Return the location of this value.
Operation * getDefiningOp() const
If this value is the result of an operation, return the operation that defines it.
void registerOperationLocation(Operation *op, unsigned line, unsigned col)
Register the location, line and column, within the buffer that the given operation was printed at.
const OpPrintingFlags & getPrinterFlags() const
Get the printer flags.
auto getResourcePrinters()
Return the non-dialect resource printers.
LogicalResult pushCyclicPrinting(const void *opaquePointer)
SSANameState & getSSANameState()
Get the state used for SSA names.
DialectInterfaceCollection< OpAsmDialectInterface > & getDialectInterfaces()
Return the dialects within the context that implement OpAsmDialectInterface.
AliasState & getAliasState()
Get the state used for aliases.
void initializeAliases(Operation *op)
Initialize the alias state to enable the printing of aliases.
AsmStateImpl(Operation *op, const OpPrintingFlags &printerFlags, AsmState::LocationMap *locationMap)
DenseMap< Dialect *, SetVector< AsmDialectResourceHandle > > & getDialectResources()
Return the referenced dialect resources within the printer.
AsmStateImpl(MLIRContext *ctx, const OpPrintingFlags &printerFlags, AsmState::LocationMap *locationMap)
DistinctState & getDistinctState()
Get the state used for distinct attribute identifiers.
Base class for DenseArrayAttr that is instantiated and specialized for each supported element type be...
static DenseArrayAttrImpl get(MLIRContext *context, ArrayRef< T > content)
Builder from ArrayRef<T>.
void printType(Type type, AsmPrinter &printer)
Prints an LLVM Dialect type.
LogicalResult parseCommaSeparatedList(llvm::cl::Option &opt, StringRef argName, StringRef optionStr, function_ref< LogicalResult(StringRef)> elementParseFn)
Parse a string containing a list of comma-delimited elements, invoking the given parser for each sub-...
void printDimensionList(raw_ostream &stream, Range &&shape)
constexpr void enumerate(std::tuple< Tys... > &tuple, CallbackT &&callback)
bool operator<(const Fraction &x, const Fraction &y)
Include the generated interface declarations.
ParseResult parseDimensionList(OpAsmParser &parser, DenseI64ArrayAttr &dimensions)
StringRef toString(AsmResourceEntryKind kind)
Type getType(OpFoldResult ofr)
Returns the int type of the integer in ofr.
OpAsmAliasResult
Holds the result of OpAsm{Dialect,Attr,Type}Interface::getAlias hook call.
@ NoAlias
The object (type or attribute) is not supported by the hook and an alias was not provided.
@ CeilDiv
RHS of ceildiv is always a constant or a symbolic expression.
@ Mul
RHS of mul is always a constant or a symbolic expression.
@ Mod
RHS of mod is always a constant or a symbolic expression with a positive value.
@ DimId
Dimensional identifier.
@ FloorDiv
RHS of floordiv is always a constant or a symbolic expression.
@ Constant
Constant integer.
@ SymbolId
Symbolic identifier.
void registerAsmPrinterCLOptions()
Register a set of useful command-line options that can be used to configure various flags within the ...
Type parseType(llvm::StringRef typeStr, MLIRContext *context, size_t *numRead=nullptr, bool isKnownNullTerminated=false)
This parses a single MLIR type to an MLIR context if it was valid.
AsmResourceEntryKind
This enum represents the different kinds of resource values.
@ Blob
A blob of data with an accompanying alignment.
LogicalResult verify(Operation *op, bool verifyRecursively=true)
Perform (potentially expensive) checks of invariants, used to detect compiler bugs,...
raw_ostream & operator<<(raw_ostream &os, const AliasResult &result)
Represents a range (offset, size, and stride) where each element of the triple may be dynamic or stat...
This trait is used to determine if a storage user, like Type, is mutable or not.