diff --git a/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td b/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td --- a/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td +++ b/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td @@ -24,7 +24,8 @@ // ----- def SPV_AddressOfOp : SPV_Op<"mlir.addressof", - [DeclareOpInterfaceMethods, InFunctionScope, NoSideEffect]> { + [DeclareOpInterfaceMethods, + InFunctionScope, NoSideEffect]> { let summary = "Get the address of a global variable."; let description = [{ @@ -70,7 +71,9 @@ // ----- def SPV_ConstantOp : SPV_Op<"Constant", - [ConstantLike, DeclareOpInterfaceMethods, NoSideEffect]> { + [ConstantLike, + DeclareOpInterfaceMethods, + NoSideEffect]> { let summary = "The op that declares a SPIR-V normal constant"; let description = [{ diff --git a/mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td b/mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td --- a/mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td +++ b/mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td @@ -135,7 +135,7 @@ def Shape_ConstSizeOp : Shape_Op<"const_size", [ ConstantLike, NoSideEffect, - DeclareOpInterfaceMethods + DeclareOpInterfaceMethods ]> { let summary = "Creates a constant of type `shape.size`"; let description = [{ diff --git a/mlir/include/mlir/Dialect/StandardOps/IR/Ops.td b/mlir/include/mlir/Dialect/StandardOps/IR/Ops.td --- a/mlir/include/mlir/Dialect/StandardOps/IR/Ops.td +++ b/mlir/include/mlir/Dialect/StandardOps/IR/Ops.td @@ -1032,7 +1032,8 @@ //===----------------------------------------------------------------------===// def ConstantOp : Std_Op<"constant", - [ConstantLike, NoSideEffect, DeclareOpInterfaceMethods]> { + [ConstantLike, NoSideEffect, + DeclareOpInterfaceMethods]> { let summary = "constant"; let description = [{ Syntax: diff --git a/mlir/include/mlir/IR/OpAsmInterface.td b/mlir/include/mlir/IR/OpAsmInterface.td --- a/mlir/include/mlir/IR/OpAsmInterface.td +++ b/mlir/include/mlir/IR/OpAsmInterface.td @@ -47,7 +47,20 @@ %first_result, %middle_results:2, %0 = "my.op" ... ``` }], - "void", "getAsmResultNames", (ins "::mlir::OpAsmSetValueNameFn":$setNameFn) + "void", "getAsmResultNames", + (ins "::mlir::OpAsmSetValueNameFn":$setNameFn), + "", ";" + >, + StaticInterfaceMethod<[{ + Return the default dialect used when printing/parsing operations in + regions nested under this operation. This allows to elide the dialect + prefix from the operation name, for example it would be possible to omit + the `spv.` prefix from all operations in a SpirV module if this method + returned `spv`. The default implementation + returns an empty string which is ignored: the parent context will be used + instead. At the top-level, the `builtin` dialect is the default. + }], + "StringRef", "getDefaultDialect", (ins), "", "return \"\";" >, ]; } diff --git a/mlir/include/mlir/IR/OpDefinition.h b/mlir/include/mlir/IR/OpDefinition.h --- a/mlir/include/mlir/IR/OpDefinition.h +++ b/mlir/include/mlir/IR/OpDefinition.h @@ -180,7 +180,8 @@ // The fallback for the printer is to print it the generic assembly form. static void print(Operation *op, OpAsmPrinter &p); - static void printOpName(Operation *op, OpAsmPrinter &p); + static void printOpName(Operation *op, OpAsmPrinter &p, + StringRef defaultDialect); /// Mutability management is handled by the OpWrapper/OpConstWrapper classes, /// so we can cast it away here. @@ -1762,7 +1763,7 @@ static std::enable_if_t::value, AbstractOperation::PrintAssemblyFn> getPrintAssemblyFnImpl() { - return [](Operation *op, OpAsmPrinter &printer) { + return [](Operation *op, OpAsmPrinter &printer, StringRef defaultDialect) { return OpState::print(op, printer); }; } @@ -1774,8 +1775,9 @@ getPrintAssemblyFnImpl() { return &printAssembly; } - static void printAssembly(Operation *op, OpAsmPrinter &p) { - OpState::printOpName(op, p); + static void printAssembly(Operation *op, OpAsmPrinter &p, + StringRef defaultDialect) { + OpState::printOpName(op, p, defaultDialect); return cast(op).print(p); } /// Implementation of `VerifyInvariantsFn` AbstractOperation hook. diff --git a/mlir/include/mlir/IR/OperationSupport.h b/mlir/include/mlir/IR/OperationSupport.h --- a/mlir/include/mlir/IR/OperationSupport.h +++ b/mlir/include/mlir/IR/OperationSupport.h @@ -77,7 +77,7 @@ using ParseAssemblyFn = llvm::unique_function; using PrintAssemblyFn = - llvm::unique_function; + llvm::unique_function; using VerifyInvariantsFn = llvm::unique_function; @@ -97,8 +97,9 @@ const ParseAssemblyFn &getParseAssemblyFn() const { return parseAssemblyFn; } /// This hook implements the AsmPrinter for this operation. - void printAssembly(Operation *op, OpAsmPrinter &p) const { - return printAssemblyFn(op, p); + void printAssembly(Operation *op, OpAsmPrinter &p, + StringRef defaultDialect) const { + return printAssemblyFn(op, p, defaultDialect); } /// This hook implements the verifier for this operation. It should emits an diff --git a/mlir/lib/IR/AsmPrinter.cpp b/mlir/lib/IR/AsmPrinter.cpp --- a/mlir/lib/IR/AsmPrinter.cpp +++ b/mlir/lib/IR/AsmPrinter.cpp @@ -371,7 +371,7 @@ // Check to see if this is a known operation. If so, use the registered // custom printer hook. if (auto *opInfo = op->getAbstractOperation()) { - opInfo->printAssembly(op, *this); + opInfo->printAssembly(op, *this, /*defaultDialect*/ ""); return; } } @@ -2424,6 +2424,13 @@ } private: + // Contains the stack of default dialect to use when printing regions. + // A new dialect is pushed to the stack before parsing regions nested under an + // operation implementing `OpAsmOpInterface`, and popped when done. At the + // top-level we start with "builtin" as the default, so that the top-level + // `module` operation prints as-is. + SmallVector defaultDialectStack{"builtin"}; + /// The number of spaces used for indenting nested operations. const static unsigned indentWidth = 2; @@ -2503,7 +2510,7 @@ // Check to see if this is a known operation. If so, use the registered // custom printer hook. if (auto *opInfo = op->getAbstractOperation()) { - opInfo->printAssembly(op, *this); + opInfo->printAssembly(op, *this, defaultDialectStack.back()); return; } // Otherwise try to dispatch to the dialect, if available. @@ -2511,6 +2518,8 @@ if (auto opPrinter = dialect->getOperationPrinter(op)) { // Print the op name first. StringRef name = op->getName().getStringRef(); + if (name.startswith((defaultDialectStack.back() + ".").str())) + name = name.drop_front(defaultDialectStack.back().size() + 1); printEscapedString(name, os); // Print the op now. opPrinter(op, *this); @@ -2657,6 +2666,22 @@ bool printEmptyBlock) { os << " {" << newLine; if (!region.empty()) { + // RAII struct to pop the default dialect from the `defaultDialectStack` + // when we're done with printing this region. + struct RestoreDefaultDialect { + RestoreDefaultDialect(SmallVector &defaultDialectStack) + : defaultDialectStack(defaultDialectStack) {} + ~RestoreDefaultDialect() { defaultDialectStack.pop_back(); } + + private: + SmallVector &defaultDialectStack; + }; + if (auto iface = dyn_cast(region.getParentOp())) + defaultDialectStack.push_back(iface.getDefaultDialect()); + else + defaultDialectStack.push_back("builtin"); + RestoreDefaultDialect r(defaultDialectStack); + auto *entryBlock = ®ion.front(); // Force printing the block header if printEmptyBlock is set and the block // is empty or if printEntryBlockArgs is set and there are arguments to diff --git a/mlir/lib/IR/Operation.cpp b/mlir/lib/IR/Operation.cpp --- a/mlir/lib/IR/Operation.cpp +++ b/mlir/lib/IR/Operation.cpp @@ -643,9 +643,12 @@ // The fallback for the printer is to print in the generic assembly form. void OpState::print(Operation *op, OpAsmPrinter &p) { p.printGenericOp(op); } // The fallback for the printer is to print in the generic assembly form. -void OpState::printOpName(Operation *op, OpAsmPrinter &p) { +void OpState::printOpName(Operation *op, OpAsmPrinter &p, + StringRef defaultDialect) { StringRef name = op->getName().getStringRef(); - if (name.startswith("std.")) + if (name.startswith((defaultDialect + ".").str())) + name = name.drop_front(defaultDialect.size() + 1); + else if (name.startswith("std.")) name = name.drop_front(4); llvm::printEscapedString(name, p.getStream()); } diff --git a/mlir/lib/Parser/Parser.cpp b/mlir/lib/Parser/Parser.cpp --- a/mlir/lib/Parser/Parser.cpp +++ b/mlir/lib/Parser/Parser.cpp @@ -1843,31 +1843,36 @@ Operation * OperationParser::parseCustomOperation(ArrayRef resultIDs) { llvm::SMLoc opLoc = getToken().getLoc(); - StringRef opName = getTokenSpelling(); + std::string opName = getTokenSpelling().str(); auto *opDefinition = AbstractOperation::lookup(opName, getContext()); + StringRef defaultDialect = getState().defaultDialectStack.back(); Dialect *dialect = nullptr; if (opDefinition) { dialect = &opDefinition->dialect; } else { - if (opName.contains('.')) { + if (StringRef(opName).contains('.')) { // This op has a dialect, we try to check if we can register it in the // context on the fly. - StringRef dialectName = opName.split('.').first; + StringRef dialectName = StringRef(opName).split('.').first; dialect = getContext()->getLoadedDialect(dialectName); if (!dialect && (dialect = getContext()->getOrLoadDialect(dialectName))) opDefinition = AbstractOperation::lookup(opName, getContext()); } else { - // If the operation name has no namespace prefix we treat it as a builtin - // or standard operation and prefix it with "builtin" or "std". - // TODO: Remove the special casing here. - opDefinition = AbstractOperation::lookup(Twine("builtin." + opName).str(), - getContext()); + // If the operation name has no namespace prefix we lookup the current + // default dialect (set through OpAsmOpInterface). + opDefinition = AbstractOperation::lookup( + Twine(defaultDialect + "." + opName).str(), getContext()); if (!opDefinition && getContext()->getOrLoadDialect("std")) { opDefinition = AbstractOperation::lookup(Twine("std." + opName).str(), getContext()); } - if (opDefinition) - opName = opDefinition->name.strref(); + if (opDefinition) { + dialect = &opDefinition->dialect; + opName = opDefinition->name.str(); + } else { + dialect = getContext()->getLoadedDialect(defaultDialect); + opName = (defaultDialect + "." + opName).str(); + } } } @@ -1877,10 +1882,14 @@ function_ref parseAssemblyFn; bool isIsolatedFromAbove = false; + defaultDialect = "builtin"; if (opDefinition) { parseAssemblyFn = opDefinition->getParseAssemblyFn(); isIsolatedFromAbove = opDefinition->hasTrait(); + auto *iface = opDefinition->getInterface(); + if (iface && !iface->getDefaultDialect().empty()) + defaultDialect = iface->getDefaultDialect(); } else { Optional dialectHook; if (dialect) @@ -1891,14 +1900,23 @@ } parseAssemblyFn = *dialectHook; } + struct RestoreDefaultDialect { + RestoreDefaultDialect(SmallVector &defaultDialectStack) + : defaultDialectStack(defaultDialectStack) {} + ~RestoreDefaultDialect() { defaultDialectStack.pop_back(); } + + private: + SmallVector &defaultDialectStack; + }; + getState().defaultDialectStack.push_back(defaultDialect); + RestoreDefaultDialect r(getState().defaultDialectStack); consumeToken(); // If the custom op parser crashes, produce some indication to help // debugging. - std::string opNameStr = opName.str(); llvm::PrettyStackTraceFormat fmt("MLIR Parser: custom op parser '%s'", - opNameStr.c_str()); + opName.c_str()); // Get location information for the operation. auto srcLocation = getEncodedSourceLocation(opLoc); diff --git a/mlir/lib/Parser/ParserState.h b/mlir/lib/Parser/ParserState.h --- a/mlir/lib/Parser/ParserState.h +++ b/mlir/lib/Parser/ParserState.h @@ -82,6 +82,13 @@ /// An optional pointer to a struct containing high level parser state to be /// populated during parsing. AsmParserState *asmState; + + // Contains the stack of default dialect to use when parsing regions. + // A new dialect get pushed to the stack before parsing regions nested + // under an operation implementing `OpAsmOpInterface`, and + // popped when done. At the top-level we start with "builtin" as the + // default, so that the top-level `module` operation parses as-is. + SmallVector defaultDialectStack{"builtin"}; }; } // end namespace detail diff --git a/mlir/test/Conversion/AsyncToLLVM/convert-runtime-to-llvm.mlir b/mlir/test/Conversion/AsyncToLLVM/convert-runtime-to-llvm.mlir --- a/mlir/test/Conversion/AsyncToLLVM/convert-runtime-to-llvm.mlir +++ b/mlir/test/Conversion/AsyncToLLVM/convert-runtime-to-llvm.mlir @@ -21,7 +21,7 @@ // CHECK-LABEL: @create_group func @create_group() { // CHECK: %[[C:.*]] = constant 1 : index - // CHECK: %[[S:.*]] = builtin.unrealized_conversion_cast %[[C]] : index to i64 + // CHECK: %[[S:.*]] = unrealized_conversion_cast %[[C]] : index to i64 %c = constant 1 : index // CHECK: %[[GROUP:.*]] = call @mlirAsyncRuntimeCreateGroup(%[[S]]) %0 = async.runtime.create_group %c: !async.group diff --git a/mlir/test/Conversion/ComplexToLLVM/convert-to-llvm.mlir b/mlir/test/Conversion/ComplexToLLVM/convert-to-llvm.mlir --- a/mlir/test/Conversion/ComplexToLLVM/convert-to-llvm.mlir +++ b/mlir/test/Conversion/ComplexToLLVM/convert-to-llvm.mlir @@ -12,9 +12,9 @@ // CHECK-LABEL: func @complex_extract // CHECK-SAME: (%[[CPLX:.*]]: complex) -// CHECK-NEXT: %[[CAST0:.*]] = builtin.unrealized_conversion_cast %[[CPLX]] : complex to !llvm.struct<(f32, f32)> +// CHECK-NEXT: %[[CAST0:.*]] = unrealized_conversion_cast %[[CPLX]] : complex to !llvm.struct<(f32, f32)> // CHECK-NEXT: %[[REAL:.*]] = llvm.extractvalue %[[CAST0]][0] : !llvm.struct<(f32, f32)> -// CHECK-NEXT: %[[CAST1:.*]] = builtin.unrealized_conversion_cast %[[CPLX]] : complex to !llvm.struct<(f32, f32)> +// CHECK-NEXT: %[[CAST1:.*]] = unrealized_conversion_cast %[[CPLX]] : complex to !llvm.struct<(f32, f32)> // CHECK-NEXT: %[[IMAG:.*]] = llvm.extractvalue %[[CAST1]][1] : !llvm.struct<(f32, f32)> func @complex_extract(%cplx: complex) { %real1 = complex.re %cplx : complex @@ -70,8 +70,8 @@ %div = complex.div %lhs, %rhs : complex return %div : complex } -// CHECK: %[[CASTED_LHS:.*]] = builtin.unrealized_conversion_cast %[[LHS]] : complex to ![[C_TY:.*>]] -// CHECK: %[[CASTED_RHS:.*]] = builtin.unrealized_conversion_cast %[[RHS]] : complex to ![[C_TY]] +// CHECK: %[[CASTED_LHS:.*]] = unrealized_conversion_cast %[[LHS]] : complex to ![[C_TY:.*>]] +// CHECK: %[[CASTED_RHS:.*]] = unrealized_conversion_cast %[[RHS]] : complex to ![[C_TY]] // CHECK: %[[LHS_RE:.*]] = llvm.extractvalue %[[CASTED_LHS]][0] : ![[C_TY]] // CHECK: %[[LHS_IM:.*]] = llvm.extractvalue %[[CASTED_LHS]][1] : ![[C_TY]] @@ -97,7 +97,7 @@ // CHECK: %[[IMAG:.*]] = llvm.fdiv %[[IMAG_TMP_2]], %[[SQ_NORM]] : f32 // CHECK: %[[RESULT_2:.*]] = llvm.insertvalue %[[IMAG]], %[[RESULT_1]][1] : ![[C_TY]] // -// CHECK: %[[CASTED_RESULT:.*]] = builtin.unrealized_conversion_cast %[[RESULT_2]] : ![[C_TY]] to complex +// CHECK: %[[CASTED_RESULT:.*]] = unrealized_conversion_cast %[[RESULT_2]] : ![[C_TY]] to complex // CHECK: return %[[CASTED_RESULT]] : complex // CHECK-LABEL: func @complex_mul @@ -106,8 +106,8 @@ %mul = complex.mul %lhs, %rhs : complex return %mul : complex } -// CHECK: %[[CASTED_LHS:.*]] = builtin.unrealized_conversion_cast %[[LHS]] : complex to ![[C_TY:.*>]] -// CHECK: %[[CASTED_RHS:.*]] = builtin.unrealized_conversion_cast %[[RHS]] : complex to ![[C_TY]] +// CHECK: %[[CASTED_LHS:.*]] = unrealized_conversion_cast %[[LHS]] : complex to ![[C_TY:.*>]] +// CHECK: %[[CASTED_RHS:.*]] = unrealized_conversion_cast %[[RHS]] : complex to ![[C_TY]] // CHECK: %[[LHS_RE:.*]] = llvm.extractvalue %[[CASTED_LHS]][0] : ![[C_TY]] // CHECK: %[[LHS_IM:.*]] = llvm.extractvalue %[[CASTED_LHS]][1] : ![[C_TY]] @@ -126,7 +126,7 @@ // CHECK: %[[RESULT_1:.*]] = llvm.insertvalue %[[REAL]], %[[RESULT_0]][0] // CHECK: %[[RESULT_2:.*]] = llvm.insertvalue %[[IMAG]], %[[RESULT_1]][1] -// CHECK: %[[CASTED_RESULT:.*]] = builtin.unrealized_conversion_cast %[[RESULT_2]] : ![[C_TY]] to complex +// CHECK: %[[CASTED_RESULT:.*]] = unrealized_conversion_cast %[[RESULT_2]] : ![[C_TY]] to complex // CHECK: return %[[CASTED_RESULT]] : complex // CHECK-LABEL: func @complex_abs @@ -135,7 +135,7 @@ %abs = complex.abs %arg: complex return %abs : f32 } -// CHECK: %[[CASTED_ARG:.*]] = builtin.unrealized_conversion_cast %[[ARG]] : complex to ![[C_TY:.*>]] +// CHECK: %[[CASTED_ARG:.*]] = unrealized_conversion_cast %[[ARG]] : complex to ![[C_TY:.*>]] // CHECK: %[[REAL:.*]] = llvm.extractvalue %[[CASTED_ARG]][0] : ![[C_TY]] // CHECK: %[[IMAG:.*]] = llvm.extractvalue %[[CASTED_ARG]][1] : ![[C_TY]] // CHECK-DAG: %[[REAL_SQ:.*]] = llvm.fmul %[[REAL]], %[[REAL]] : f32 diff --git a/mlir/test/Conversion/MemRefToLLVM/convert-dynamic-memref-ops.mlir b/mlir/test/Conversion/MemRefToLLVM/convert-dynamic-memref-ops.mlir --- a/mlir/test/Conversion/MemRefToLLVM/convert-dynamic-memref-ops.mlir +++ b/mlir/test/Conversion/MemRefToLLVM/convert-dynamic-memref-ops.mlir @@ -4,8 +4,8 @@ // CHECK-LABEL: func @mixed_alloc( // CHECK: %[[Marg:.*]]: index, %[[Narg:.*]]: index) func @mixed_alloc(%arg0: index, %arg1: index) -> memref { -// CHECK: %[[M:.*]] = builtin.unrealized_conversion_cast %[[Marg]] -// CHECK: %[[N:.*]] = builtin.unrealized_conversion_cast %[[Narg]] +// CHECK: %[[M:.*]] = unrealized_conversion_cast %[[Marg]] +// CHECK: %[[N:.*]] = unrealized_conversion_cast %[[Narg]] // CHECK: %[[c42:.*]] = llvm.mlir.constant(42 : index) : i64 // CHECK-NEXT: %[[one:.*]] = llvm.mlir.constant(1 : index) : i64 // CHECK-NEXT: %[[st0:.*]] = llvm.mul %[[N]], %[[c42]] : i64 @@ -46,8 +46,8 @@ // CHECK-LABEL: func @dynamic_alloc( // CHECK: %[[Marg:.*]]: index, %[[Narg:.*]]: index) func @dynamic_alloc(%arg0: index, %arg1: index) -> memref { -// CHECK: %[[M:.*]] = builtin.unrealized_conversion_cast %[[Marg]] -// CHECK: %[[N:.*]] = builtin.unrealized_conversion_cast %[[Narg]] +// CHECK: %[[M:.*]] = unrealized_conversion_cast %[[Marg]] +// CHECK: %[[N:.*]] = unrealized_conversion_cast %[[Narg]] // CHECK-NEXT: %[[one:.*]] = llvm.mlir.constant(1 : index) : i64 // CHECK-NEXT: %[[sz:.*]] = llvm.mul %[[N]], %[[M]] : i64 // CHECK-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr @@ -73,8 +73,8 @@ // CHECK-LABEL: func @dynamic_alloca // CHECK: %[[Marg:.*]]: index, %[[Narg:.*]]: index) func @dynamic_alloca(%arg0: index, %arg1: index) -> memref { -// CHECK: %[[M:.*]] = builtin.unrealized_conversion_cast %[[Marg]] -// CHECK: %[[N:.*]] = builtin.unrealized_conversion_cast %[[Narg]] +// CHECK: %[[M:.*]] = unrealized_conversion_cast %[[Marg]] +// CHECK: %[[N:.*]] = unrealized_conversion_cast %[[Narg]] // CHECK-NEXT: %[[st1:.*]] = llvm.mlir.constant(1 : index) : i64 // CHECK-NEXT: %[[num_elems:.*]] = llvm.mul %[[N]], %[[M]] : i64 // CHECK-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr @@ -167,8 +167,8 @@ // CHECK-LABEL: func @mixed_load( // CHECK: %{{.*}}, %[[Iarg:.*]]: index, %[[Jarg:.*]]: index) func @mixed_load(%mixed : memref<42x?xf32>, %i : index, %j : index) { -// CHECK: %[[I:.*]] = builtin.unrealized_conversion_cast %[[Iarg]] -// CHECK: %[[J:.*]] = builtin.unrealized_conversion_cast %[[Jarg]] +// CHECK: %[[I:.*]] = unrealized_conversion_cast %[[Iarg]] +// CHECK: %[[J:.*]] = unrealized_conversion_cast %[[Jarg]] // CHECK: %[[ptr:.*]] = llvm.extractvalue %[[ld:.*]][1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: %[[st0:.*]] = llvm.extractvalue %[[ld]][4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : i64 @@ -184,8 +184,8 @@ // CHECK-LABEL: func @dynamic_load( // CHECK: %{{.*}}, %[[Iarg:.*]]: index, %[[Jarg:.*]]: index) func @dynamic_load(%dynamic : memref, %i : index, %j : index) { -// CHECK: %[[I:.*]] = builtin.unrealized_conversion_cast %[[Iarg]] -// CHECK: %[[J:.*]] = builtin.unrealized_conversion_cast %[[Jarg]] +// CHECK: %[[I:.*]] = unrealized_conversion_cast %[[Iarg]] +// CHECK: %[[J:.*]] = unrealized_conversion_cast %[[Jarg]] // CHECK: %[[ptr:.*]] = llvm.extractvalue %[[ld:.*]][1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: %[[st0:.*]] = llvm.extractvalue %[[ld]][4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : i64 @@ -201,8 +201,8 @@ // CHECK-LABEL: func @prefetch // CHECK: %{{.*}}, %[[Iarg:.*]]: index, %[[Jarg:.*]]: index) func @prefetch(%A : memref, %i : index, %j : index) { -// CHECK: %[[I:.*]] = builtin.unrealized_conversion_cast %[[Iarg]] -// CHECK: %[[J:.*]] = builtin.unrealized_conversion_cast %[[Jarg]] +// CHECK: %[[I:.*]] = unrealized_conversion_cast %[[Iarg]] +// CHECK: %[[J:.*]] = unrealized_conversion_cast %[[Jarg]] // CHECK: %[[ptr:.*]] = llvm.extractvalue %[[ld:.*]][1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: %[[st0:.*]] = llvm.extractvalue %[[ld]][4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : i64 @@ -231,8 +231,8 @@ // CHECK-LABEL: func @dynamic_store // CHECK: %{{.*}}, %[[Iarg:.*]]: index, %[[Jarg:.*]]: index func @dynamic_store(%dynamic : memref, %i : index, %j : index, %val : f32) { -// CHECK: %[[I:.*]] = builtin.unrealized_conversion_cast %[[Iarg]] -// CHECK: %[[J:.*]] = builtin.unrealized_conversion_cast %[[Jarg]] +// CHECK: %[[I:.*]] = unrealized_conversion_cast %[[Iarg]] +// CHECK: %[[J:.*]] = unrealized_conversion_cast %[[Jarg]] // CHECK: %[[ptr:.*]] = llvm.extractvalue %[[ld:.*]][1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: %[[st0:.*]] = llvm.extractvalue %[[ld]][4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : i64 @@ -248,8 +248,8 @@ // CHECK-LABEL: func @mixed_store // CHECK: %{{.*}}, %[[Iarg:.*]]: index, %[[Jarg:.*]]: index func @mixed_store(%mixed : memref<42x?xf32>, %i : index, %j : index, %val : f32) { -// CHECK: %[[I:.*]] = builtin.unrealized_conversion_cast %[[Iarg]] -// CHECK: %[[J:.*]] = builtin.unrealized_conversion_cast %[[Jarg]] +// CHECK: %[[I:.*]] = unrealized_conversion_cast %[[Iarg]] +// CHECK: %[[J:.*]] = unrealized_conversion_cast %[[Jarg]] // CHECK: %[[ptr:.*]] = llvm.extractvalue %[[ld:.*]][1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: %[[st0:.*]] = llvm.extractvalue %[[ld]][4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : i64 @@ -381,7 +381,7 @@ // CHECK-DAG: %[[SIZES:.*]] = llvm.extractvalue %{{.*}}[3] : ![[DESCR_TY:.*]] // CHECK-DAG: %[[SIZES_PTR:.*]] = llvm.alloca %[[C1]] x !llvm.array<2 x i64> : (i64) -> !llvm.ptr> // CHECK-DAG: llvm.store %[[SIZES]], %[[SIZES_PTR]] : !llvm.ptr> - // CHECK-DAG: %[[IDX:.*]] = builtin.unrealized_conversion_cast %[[IDXarg]] + // CHECK-DAG: %[[IDX:.*]] = unrealized_conversion_cast %[[IDXarg]] // CHECK-DAG: %[[RESULT_PTR:.*]] = llvm.getelementptr %[[SIZES_PTR]][%[[C0]], %[[IDX]]] : (!llvm.ptr>, i64, i64) -> !llvm.ptr // CHECK-DAG: %[[RESULT:.*]] = llvm.load %[[RESULT_PTR]] : !llvm.ptr %result = memref.dim %arg, %idx : memref<3x?xf32> @@ -397,7 +397,7 @@ : memref<2x3xf32> to memref<6x1xf32> return } -// CHECK: [[INPUT:%.*]] = builtin.unrealized_conversion_cast %{{.*}} : +// CHECK: [[INPUT:%.*]] = unrealized_conversion_cast %{{.*}} : // CHECK: to [[TY:!.*]] // CHECK: [[OUT_0:%.*]] = llvm.mlir.undef : [[TY]] // CHECK: [[BASE_PTR:%.*]] = llvm.extractvalue [[INPUT]][0] : [[TY]] @@ -433,12 +433,12 @@ // CHECK-SAME: ([[OFFSETarg:%[a-z,0-9]+]]: index, // CHECK-SAME: [[SIZE_0arg:%[a-z,0-9]+]]: index, [[SIZE_1arg:%[a-z,0-9]+]]: index, // CHECK-SAME: [[STRIDE_0arg:%[a-z,0-9]+]]: index, [[STRIDE_1arg:%[a-z,0-9]+]]: index, -// CHECK: [[INPUT:%.*]] = builtin.unrealized_conversion_cast -// CHECK: [[OFFSET:%.*]] = builtin.unrealized_conversion_cast [[OFFSETarg]] -// CHECK: [[SIZE_0:%.*]] = builtin.unrealized_conversion_cast [[SIZE_0arg]] -// CHECK: [[SIZE_1:%.*]] = builtin.unrealized_conversion_cast [[SIZE_1arg]] -// CHECK: [[STRIDE_0:%.*]] = builtin.unrealized_conversion_cast [[STRIDE_0arg]] -// CHECK: [[STRIDE_1:%.*]] = builtin.unrealized_conversion_cast [[STRIDE_1arg]] +// CHECK: [[INPUT:%.*]] = unrealized_conversion_cast +// CHECK: [[OFFSET:%.*]] = unrealized_conversion_cast [[OFFSETarg]] +// CHECK: [[SIZE_0:%.*]] = unrealized_conversion_cast [[SIZE_0arg]] +// CHECK: [[SIZE_1:%.*]] = unrealized_conversion_cast [[SIZE_1arg]] +// CHECK: [[STRIDE_0:%.*]] = unrealized_conversion_cast [[STRIDE_0arg]] +// CHECK: [[STRIDE_1:%.*]] = unrealized_conversion_cast [[STRIDE_1arg]] // CHECK: [[OUT_0:%.*]] = llvm.mlir.undef : [[TY:!.*]] // CHECK: [[DESCRIPTOR:%.*]] = llvm.extractvalue [[INPUT]][1] : !llvm.struct<(i64, ptr)> // CHECK: [[BASE_PTR_PTR:%.*]] = llvm.bitcast [[DESCRIPTOR]] : !llvm.ptr to !llvm.ptr> @@ -464,8 +464,8 @@ : (memref<2x3xf32>, memref) -> memref<*xf32> return } -// CHECK: [[INPUT:%.*]] = builtin.unrealized_conversion_cast %{{.*}} to [[INPUT_TY:!.*]] -// CHECK: [[SHAPE:%.*]] = builtin.unrealized_conversion_cast %{{.*}} to [[SHAPE_TY:!.*]] +// CHECK: [[INPUT:%.*]] = unrealized_conversion_cast %{{.*}} to [[INPUT_TY:!.*]] +// CHECK: [[SHAPE:%.*]] = unrealized_conversion_cast %{{.*}} to [[SHAPE_TY:!.*]] // CHECK: [[RANK:%.*]] = llvm.extractvalue [[SHAPE]][3, 0] : [[SHAPE_TY]] // CHECK: [[UNRANKED_OUT_O:%.*]] = llvm.mlir.undef : !llvm.struct<(i64, ptr)> // CHECK: [[UNRANKED_OUT_1:%.*]] = llvm.insertvalue [[RANK]], [[UNRANKED_OUT_O]][0] : !llvm.struct<(i64, ptr)> diff --git a/mlir/test/Conversion/MemRefToLLVM/convert-static-memref-ops.mlir b/mlir/test/Conversion/MemRefToLLVM/convert-static-memref-ops.mlir --- a/mlir/test/Conversion/MemRefToLLVM/convert-static-memref-ops.mlir +++ b/mlir/test/Conversion/MemRefToLLVM/convert-static-memref-ops.mlir @@ -128,8 +128,8 @@ // CHECK: %[[I:.*]]: index, // CHECK: %[[J:.*]]: index) func @static_load(%static : memref<10x42xf32>, %i : index, %j : index) { -// CHECK: %[[II:.*]] = builtin.unrealized_conversion_cast %[[I]] -// CHECK: %[[JJ:.*]] = builtin.unrealized_conversion_cast %[[J]] +// CHECK: %[[II:.*]] = unrealized_conversion_cast %[[I]] +// CHECK: %[[JJ:.*]] = unrealized_conversion_cast %[[J]] // CHECK: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[st0:.*]] = llvm.mlir.constant(42 : index) : i64 // CHECK: %[[offI:.*]] = llvm.mul %[[II]], %[[st0]] : i64 @@ -156,8 +156,8 @@ // CHECK: %[[MEMREF:.*]]: memref<10x42xf32>, // CHECK-SAME: %[[I:.*]]: index, %[[J:.*]]: index, func @static_store(%static : memref<10x42xf32>, %i : index, %j : index, %val : f32) { -// CHECK: %[[II:.*]] = builtin.unrealized_conversion_cast %[[I]] -// CHECK: %[[JJ:.*]] = builtin.unrealized_conversion_cast %[[J]] +// CHECK: %[[II:.*]] = unrealized_conversion_cast %[[I]] +// CHECK: %[[JJ:.*]] = unrealized_conversion_cast %[[J]] // CHECK: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[st0:.*]] = llvm.mlir.constant(42 : index) : i64 // CHECK: %[[offI:.*]] = llvm.mul %[[II]], %[[st0]] : i64 @@ -200,7 +200,7 @@ %c1 = constant 1 : index %0 = memref.alloc(%c1) : memref> // CHECK: %[[CST_S:.*]] = constant 1 : index - // CHECK: %[[CST:.*]] = builtin.unrealized_conversion_cast + // CHECK: %[[CST:.*]] = unrealized_conversion_cast // CHECK: llvm.mlir.null // CHECK: llvm.getelementptr %{{.*}}[[CST]] // CHECK: llvm.ptrtoint %{{.*}} : !llvm.ptr<{{.*}}> to i32 diff --git a/mlir/test/Conversion/MemRefToLLVM/memref-to-llvm.mlir b/mlir/test/Conversion/MemRefToLLVM/memref-to-llvm.mlir --- a/mlir/test/Conversion/MemRefToLLVM/memref-to-llvm.mlir +++ b/mlir/test/Conversion/MemRefToLLVM/memref-to-llvm.mlir @@ -10,9 +10,9 @@ %0 = memref.alloc() : memref<2048xi8> // Test two dynamic sizes. - // CHECK: %[[ARG2:.*]] = builtin.unrealized_conversion_cast %[[ARG2F:.*]] - // CHECK: %[[ARG0:.*]] = builtin.unrealized_conversion_cast %[[ARG0F:.*]] - // CHECK: %[[ARG1:.*]] = builtin.unrealized_conversion_cast %[[ARG1F:.*]] + // CHECK: %[[ARG2:.*]] = unrealized_conversion_cast %[[ARG2F:.*]] + // CHECK: %[[ARG0:.*]] = unrealized_conversion_cast %[[ARG0F:.*]] + // CHECK: %[[ARG1:.*]] = unrealized_conversion_cast %[[ARG1F:.*]] // CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[BASE_PTR:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> // CHECK: %[[SHIFTED_BASE_PTR:.*]] = llvm.getelementptr %[[BASE_PTR]][%[[ARG2]]] : (!llvm.ptr, i64) -> !llvm.ptr @@ -29,8 +29,8 @@ %1 = memref.view %0[%arg2][%arg0, %arg1] : memref<2048xi8> to memref // Test one dynamic size. - // CHECK: %[[ARG2:.*]] = builtin.unrealized_conversion_cast %[[ARG2F:.*]] - // CHECK: %[[ARG1:.*]] = builtin.unrealized_conversion_cast %[[ARG1F:.*]] + // CHECK: %[[ARG2:.*]] = unrealized_conversion_cast %[[ARG2F:.*]] + // CHECK: %[[ARG1:.*]] = unrealized_conversion_cast %[[ARG1F:.*]] // CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[BASE_PTR_2:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> // CHECK: %[[SHIFTED_BASE_PTR_2:.*]] = llvm.getelementptr %[[BASE_PTR_2]][%[[ARG2]]] : (!llvm.ptr, i64) -> !llvm.ptr @@ -48,7 +48,7 @@ %3 = memref.view %0[%arg2][%arg1] : memref<2048xi8> to memref<4x?xf32> // Test static sizes. - // CHECK: %[[ARG2:.*]] = builtin.unrealized_conversion_cast %[[ARG2F:.*]] + // CHECK: %[[ARG2:.*]] = unrealized_conversion_cast %[[ARG2F:.*]] // CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[BASE_PTR_3:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> // CHECK: %[[SHIFTED_BASE_PTR_3:.*]] = llvm.getelementptr %[[BASE_PTR_3]][%[[ARG2]]] : (!llvm.ptr, i64) -> !llvm.ptr @@ -71,7 +71,7 @@ // CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> %6 = memref.alloc() : memref<2048xi8, 4> - // CHECK: %[[ARG2:.*]] = builtin.unrealized_conversion_cast %[[ARG2F:.*]] + // CHECK: %[[ARG2:.*]] = unrealized_conversion_cast %[[ARG2F:.*]] // CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[BASE_PTR_4:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> // CHECK: %[[SHIFTED_BASE_PTR_4:.*]] = llvm.getelementptr %[[BASE_PTR_4]][%[[ARG2]]] : (!llvm.ptr, i64) -> !llvm.ptr @@ -105,21 +105,21 @@ // CHECK32: %[[ARG1f:[a-zA-Z0-9]*]]: index, // CHECK32: %[[ARG2f:.*]]: index) func @subview(%0 : memref<64x4xf32, offset: 0, strides: [4, 1]>, %arg0 : index, %arg1 : index, %arg2 : index) { - // CHECK: %[[MEMREF:.*]] = builtin.unrealized_conversion_cast %[[MEM]] - // CHECK32: %[[MEMREF:.*]] = builtin.unrealized_conversion_cast %[[MEM]] - - // CHECK: %[[ARG0a:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK: %[[ARG1a:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] - // CHECK: %[[ARG0b:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK: %[[ARG1b:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] - // CHECK: %[[ARG0c:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK: %[[ARG1c:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] - // CHECK32: %[[ARG0a:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK32: %[[ARG1a:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] - // CHECK32: %[[ARG0b:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK32: %[[ARG1b:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] - // CHECK32: %[[ARG0c:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK32: %[[ARG1c:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] + // CHECK: %[[MEMREF:.*]] = unrealized_conversion_cast %[[MEM]] + // CHECK32: %[[MEMREF:.*]] = unrealized_conversion_cast %[[MEM]] + + // CHECK: %[[ARG0a:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK: %[[ARG1a:.*]] = unrealized_conversion_cast %[[ARG1f]] + // CHECK: %[[ARG0b:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK: %[[ARG1b:.*]] = unrealized_conversion_cast %[[ARG1f]] + // CHECK: %[[ARG0c:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK: %[[ARG1c:.*]] = unrealized_conversion_cast %[[ARG1f]] + // CHECK32: %[[ARG0a:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK32: %[[ARG1a:.*]] = unrealized_conversion_cast %[[ARG1f]] + // CHECK32: %[[ARG0b:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK32: %[[ARG1b:.*]] = unrealized_conversion_cast %[[ARG1f]] + // CHECK32: %[[ARG0c:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK32: %[[ARG1c:.*]] = unrealized_conversion_cast %[[ARG1f]] // CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr to !llvm.ptr @@ -178,21 +178,21 @@ // CHECK32: %[[ARG1f:[a-zA-Z0-9]*]]: index, // CHECK32: %[[ARG2f:.*]]: index) func @subview_non_zero_addrspace(%0 : memref<64x4xf32, offset: 0, strides: [4, 1], 3>, %arg0 : index, %arg1 : index, %arg2 : index) { - // CHECK: %[[MEMREF:.*]] = builtin.unrealized_conversion_cast %[[MEM]] - // CHECK32: %[[MEMREF:.*]] = builtin.unrealized_conversion_cast %[[MEM]] - - // CHECK: %[[ARG0a:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK: %[[ARG1a:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] - // CHECK: %[[ARG0b:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK: %[[ARG1b:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] - // CHECK: %[[ARG0c:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK: %[[ARG1c:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] - // CHECK32: %[[ARG0a:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK32: %[[ARG1a:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] - // CHECK32: %[[ARG0b:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK32: %[[ARG1b:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] - // CHECK32: %[[ARG0c:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK32: %[[ARG1c:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] + // CHECK: %[[MEMREF:.*]] = unrealized_conversion_cast %[[MEM]] + // CHECK32: %[[MEMREF:.*]] = unrealized_conversion_cast %[[MEM]] + + // CHECK: %[[ARG0a:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK: %[[ARG1a:.*]] = unrealized_conversion_cast %[[ARG1f]] + // CHECK: %[[ARG0b:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK: %[[ARG1b:.*]] = unrealized_conversion_cast %[[ARG1f]] + // CHECK: %[[ARG0c:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK: %[[ARG1c:.*]] = unrealized_conversion_cast %[[ARG1f]] + // CHECK32: %[[ARG0a:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK32: %[[ARG1a:.*]] = unrealized_conversion_cast %[[ARG1f]] + // CHECK32: %[[ARG0b:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK32: %[[ARG1b:.*]] = unrealized_conversion_cast %[[ARG1f]] + // CHECK32: %[[ARG0c:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK32: %[[ARG1c:.*]] = unrealized_conversion_cast %[[ARG1f]] // CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr to !llvm.ptr @@ -251,17 +251,17 @@ // CHECK32-SAME: %[[ARG1f:[a-zA-Z0-9]*]]: index // CHECK32-SAME: %[[ARG2f:[a-zA-Z0-9]*]]: index func @subview_const_size(%0 : memref<64x4xf32, offset: 0, strides: [4, 1]>, %arg0 : index, %arg1 : index, %arg2 : index) { - // CHECK: %[[MEMREF:.*]] = builtin.unrealized_conversion_cast %[[MEM]] - // CHECK32: %[[MEMREF:.*]] = builtin.unrealized_conversion_cast %[[MEM]] - - // CHECK: %[[ARG0a:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK: %[[ARG1a:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] - // CHECK: %[[ARG0b:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK: %[[ARG1b:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] - // CHECK32: %[[ARG0a:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK32: %[[ARG1a:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] - // CHECK32: %[[ARG0b:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK32: %[[ARG1b:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] + // CHECK: %[[MEMREF:.*]] = unrealized_conversion_cast %[[MEM]] + // CHECK32: %[[MEMREF:.*]] = unrealized_conversion_cast %[[MEM]] + + // CHECK: %[[ARG0a:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK: %[[ARG1a:.*]] = unrealized_conversion_cast %[[ARG1f]] + // CHECK: %[[ARG0b:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK: %[[ARG1b:.*]] = unrealized_conversion_cast %[[ARG1f]] + // CHECK32: %[[ARG0a:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK32: %[[ARG1a:.*]] = unrealized_conversion_cast %[[ARG1f]] + // CHECK32: %[[ARG0b:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK32: %[[ARG1b:.*]] = unrealized_conversion_cast %[[ARG1f]] // CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr to !llvm.ptr @@ -324,17 +324,17 @@ // CHECK32-SAME: %[[ARG1f:[a-zA-Z0-9]*]]: index // CHECK32-SAME: %[[ARG2f:[a-zA-Z0-9]*]]: index func @subview_const_stride(%0 : memref<64x4xf32, offset: 0, strides: [4, 1]>, %arg0 : index, %arg1 : index, %arg2 : index) { - // CHECK: %[[MEMREF:.*]] = builtin.unrealized_conversion_cast %[[MEM]] - // CHECK32: %[[MEMREF:.*]] = builtin.unrealized_conversion_cast %[[MEM]] - - // CHECK: %[[ARG0a:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK: %[[ARG1a:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] - // CHECK: %[[ARG0b:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK: %[[ARG1b:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] - // CHECK32: %[[ARG0a:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK32: %[[ARG1a:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] - // CHECK32: %[[ARG0b:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] - // CHECK32: %[[ARG1b:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] + // CHECK: %[[MEMREF:.*]] = unrealized_conversion_cast %[[MEM]] + // CHECK32: %[[MEMREF:.*]] = unrealized_conversion_cast %[[MEM]] + + // CHECK: %[[ARG0a:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK: %[[ARG1a:.*]] = unrealized_conversion_cast %[[ARG1f]] + // CHECK: %[[ARG0b:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK: %[[ARG1b:.*]] = unrealized_conversion_cast %[[ARG1f]] + // CHECK32: %[[ARG0a:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK32: %[[ARG1a:.*]] = unrealized_conversion_cast %[[ARG1f]] + // CHECK32: %[[ARG0b:.*]] = unrealized_conversion_cast %[[ARG0f]] + // CHECK32: %[[ARG1b:.*]] = unrealized_conversion_cast %[[ARG1f]] // CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr to !llvm.ptr @@ -386,8 +386,8 @@ // CHECK32-LABEL: func @subview_const_stride_and_offset( func @subview_const_stride_and_offset(%0 : memref<64x4xf32, offset: 0, strides: [4, 1]>) { // The last "insertvalue" that populates the memref descriptor from the function arguments. - // CHECK: %[[MEMREF:.*]] = builtin.unrealized_conversion_cast - // CHECK32: %[[MEMREF:.*]] = builtin.unrealized_conversion_cast + // CHECK: %[[MEMREF:.*]] = unrealized_conversion_cast + // CHECK32: %[[MEMREF:.*]] = unrealized_conversion_cast // CHECK32: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, ptr, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr to !llvm.ptr @@ -425,10 +425,10 @@ // CHECK32: %[[ARG1f:[a-zA-Z0-9]*]]: index, // CHECK32: %[[ARG2f:.*]]: index) func @subview_mixed_static_dynamic(%0 : memref<64x4xf32, offset: 0, strides: [4, 1]>, %arg0 : index, %arg1 : index, %arg2 : index) { - // CHECK32: %[[MEMREF:.*]] = builtin.unrealized_conversion_cast %[[MEM]] - // CHECK32: %[[ARG1:.*]] = builtin.unrealized_conversion_cast %[[ARG1f]] - // CHECK32: %[[ARG2:.*]] = builtin.unrealized_conversion_cast %[[ARG2f]] - // CHECK32: %[[ARG0:.*]] = builtin.unrealized_conversion_cast %[[ARG0f]] + // CHECK32: %[[MEMREF:.*]] = unrealized_conversion_cast %[[MEM]] + // CHECK32: %[[ARG1:.*]] = unrealized_conversion_cast %[[ARG1f]] + // CHECK32: %[[ARG2:.*]] = unrealized_conversion_cast %[[ARG2f]] + // CHECK32: %[[ARG0:.*]] = unrealized_conversion_cast %[[ARG0f]] // CHECK32: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, ptr, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr to !llvm.ptr @@ -567,7 +567,7 @@ %dim = memref.dim %unranked, %c0 : memref<*xi32> return %dim : index } -// CHECK: %[[UNRANKED_DESC:.*]] = builtin.unrealized_conversion_cast +// CHECK: %[[UNRANKED_DESC:.*]] = unrealized_conversion_cast // CHECK: %[[RANKED_DESC:.*]] = llvm.extractvalue %[[UNRANKED_DESC]][1] // CHECK-SAME: : !llvm.struct<(i64, ptr)> diff --git a/mlir/test/Conversion/MemRefToSPIRV/memref-to-spirv.mlir b/mlir/test/Conversion/MemRefToSPIRV/memref-to-spirv.mlir --- a/mlir/test/Conversion/MemRefToSPIRV/memref-to-spirv.mlir +++ b/mlir/test/Conversion/MemRefToSPIRV/memref-to-spirv.mlir @@ -16,14 +16,14 @@ // CHECK-LABEL: @load_store_zero_rank_float func @load_store_zero_rank_float(%arg0: memref, %arg1: memref) { - // CHECK: [[ARG0:%.*]] = builtin.unrealized_conversion_cast {{.+}} : memref to !spv.ptr [0])>, StorageBuffer> + // CHECK: [[ARG0:%.*]] = unrealized_conversion_cast {{.+}} : memref to !spv.ptr [0])>, StorageBuffer> // CHECK: [[ZERO1:%.*]] = spv.Constant 0 : i32 // CHECK: spv.AccessChain [[ARG0]][ // CHECK-SAME: [[ZERO1]], [[ZERO1]] // CHECK-SAME: ] : // CHECK: spv.Load "StorageBuffer" %{{.*}} : f32 %0 = memref.load %arg0[] : memref - // CHECK: [[ARG1:%.*]] = builtin.unrealized_conversion_cast {{.+}} : memref to !spv.ptr [0])>, StorageBuffer> + // CHECK: [[ARG1:%.*]] = unrealized_conversion_cast {{.+}} : memref to !spv.ptr [0])>, StorageBuffer> // CHECK: [[ZERO2:%.*]] = spv.Constant 0 : i32 // CHECK: spv.AccessChain [[ARG1]][ // CHECK-SAME: [[ZERO2]], [[ZERO2]] @@ -35,14 +35,14 @@ // CHECK-LABEL: @load_store_zero_rank_int func @load_store_zero_rank_int(%arg0: memref, %arg1: memref) { - // CHECK: [[ARG0:%.*]] = builtin.unrealized_conversion_cast {{.+}} : memref to !spv.ptr [0])>, StorageBuffer> + // CHECK: [[ARG0:%.*]] = unrealized_conversion_cast {{.+}} : memref to !spv.ptr [0])>, StorageBuffer> // CHECK: [[ZERO1:%.*]] = spv.Constant 0 : i32 // CHECK: spv.AccessChain [[ARG0]][ // CHECK-SAME: [[ZERO1]], [[ZERO1]] // CHECK-SAME: ] : // CHECK: spv.Load "StorageBuffer" %{{.*}} : i32 %0 = memref.load %arg0[] : memref - // CHECK: [[ARG1:%.*]] = builtin.unrealized_conversion_cast {{.+}} : memref to !spv.ptr [0])>, StorageBuffer> + // CHECK: [[ARG1:%.*]] = unrealized_conversion_cast {{.+}} : memref to !spv.ptr [0])>, StorageBuffer> // CHECK: [[ZERO2:%.*]] = spv.Constant 0 : i32 // CHECK: spv.AccessChain [[ARG1]][ // CHECK-SAME: [[ZERO2]], [[ZERO2]] @@ -54,11 +54,11 @@ // CHECK-LABEL: func @load_store_unknown_dim func @load_store_unknown_dim(%i: index, %source: memref, %dest: memref) { - // CHECK: %[[SRC:.+]] = builtin.unrealized_conversion_cast {{.+}} : memref to !spv.ptr [0])>, StorageBuffer> + // CHECK: %[[SRC:.+]] = unrealized_conversion_cast {{.+}} : memref to !spv.ptr [0])>, StorageBuffer> // CHECK: %[[AC0:.+]] = spv.AccessChain %[[SRC]] // CHECK: spv.Load "StorageBuffer" %[[AC0]] %0 = memref.load %source[%i] : memref - // CHECK: %[[DST:.+]] = builtin.unrealized_conversion_cast {{.+}} : memref to !spv.ptr [0])>, StorageBuffer> + // CHECK: %[[DST:.+]] = unrealized_conversion_cast {{.+}} : memref to !spv.ptr [0])>, StorageBuffer> // CHECK: %[[AC1:.+]] = spv.AccessChain %[[DST]] // CHECK: spv.Store "StorageBuffer" %[[AC1]] memref.store %0, %dest[%i]: memref @@ -68,8 +68,8 @@ // CHECK-LABEL: func @load_i1 // CHECK-SAME: (%[[SRC:.+]]: memref<4xi1>, %[[IDX:.+]]: index) func @load_i1(%src: memref<4xi1>, %i : index) -> i1 { - // CHECK: %[[SRC_CAST:.+]] = builtin.unrealized_conversion_cast %[[SRC]] : memref<4xi1> to !spv.ptr [0])>, StorageBuffer> - // CHECK: %[[IDX_CAST:.+]] = builtin.unrealized_conversion_cast %[[IDX]] + // CHECK: %[[SRC_CAST:.+]] = unrealized_conversion_cast %[[SRC]] : memref<4xi1> to !spv.ptr [0])>, StorageBuffer> + // CHECK: %[[IDX_CAST:.+]] = unrealized_conversion_cast %[[IDX]] // CHECK: %[[ZERO_0:.+]] = spv.Constant 0 : i32 // CHECK: %[[ZERO_1:.+]] = spv.Constant 0 : i32 // CHECK: %[[ONE:.+]] = spv.Constant 1 : i32 @@ -89,8 +89,8 @@ // CHECK-SAME: %[[IDX:.+]]: index func @store_i1(%dst: memref<4xi1>, %i: index) { %true = constant true - // CHECK: %[[DST_CAST:.+]] = builtin.unrealized_conversion_cast %[[DST]] : memref<4xi1> to !spv.ptr [0])>, StorageBuffer> - // CHECK: %[[IDX_CAST:.+]] = builtin.unrealized_conversion_cast %[[IDX]] + // CHECK: %[[DST_CAST:.+]] = unrealized_conversion_cast %[[DST]] : memref<4xi1> to !spv.ptr [0])>, StorageBuffer> + // CHECK: %[[IDX_CAST:.+]] = unrealized_conversion_cast %[[IDX]] // CHECK: %[[ZERO_0:.+]] = spv.Constant 0 : i32 // CHECK: %[[ZERO_1:.+]] = spv.Constant 0 : i32 // CHECK: %[[ONE:.+]] = spv.Constant 1 : i32 @@ -166,7 +166,7 @@ // CHECK-LABEL: @load_i16 // CHECK: (%[[ARG0:.+]]: {{.*}}, %[[ARG1:.+]]: index) func @load_i16(%arg0: memref<10xi16>, %index : index) { - // CHECK: %[[ARG1_CAST:.+]] = builtin.unrealized_conversion_cast %[[ARG1]] : index to i32 + // CHECK: %[[ARG1_CAST:.+]] = unrealized_conversion_cast %[[ARG1]] : index to i32 // CHECK: %[[ZERO:.+]] = spv.Constant 0 : i32 // CHECK: %[[OFFSET:.+]] = spv.Constant 0 : i32 // CHECK: %[[ONE:.+]] = spv.Constant 1 : i32 @@ -211,7 +211,7 @@ // CHECK-LABEL: @store_i1 // CHECK: (%[[ARG0:.+]]: {{.*}}, %[[ARG1:.+]]: i1) func @store_i1(%arg0: memref, %value: i1) { - // CHECK: %[[ARG0_CAST:.+]] = builtin.unrealized_conversion_cast %[[ARG0]] + // CHECK: %[[ARG0_CAST:.+]] = unrealized_conversion_cast %[[ARG0]] // CHECK: %[[ZERO:.+]] = spv.Constant 0 : i32 // CHECK: %[[FOUR:.+]] = spv.Constant 4 : i32 // CHECK: %[[EIGHT:.+]] = spv.Constant 8 : i32 @@ -237,8 +237,8 @@ // CHECK-LABEL: @store_i8 // CHECK: (%[[ARG0:.+]]: {{.*}}, %[[ARG1:.+]]: i8) func @store_i8(%arg0: memref, %value: i8) { - // CHECK: %[[ARG1_CAST:.+]] = builtin.unrealized_conversion_cast %[[ARG1]] : i8 to i32 - // CHECK: %[[ARG0_CAST:.+]] = builtin.unrealized_conversion_cast %[[ARG0]] + // CHECK: %[[ARG1_CAST:.+]] = unrealized_conversion_cast %[[ARG1]] : i8 to i32 + // CHECK: %[[ARG0_CAST:.+]] = unrealized_conversion_cast %[[ARG0]] // CHECK: %[[ZERO:.+]] = spv.Constant 0 : i32 // CHECK: %[[FOUR:.+]] = spv.Constant 4 : i32 // CHECK: %[[EIGHT:.+]] = spv.Constant 8 : i32 @@ -261,9 +261,9 @@ // CHECK-LABEL: @store_i16 // CHECK: (%[[ARG0:.+]]: memref<10xi16>, %[[ARG1:.+]]: index, %[[ARG2:.+]]: i16) func @store_i16(%arg0: memref<10xi16>, %index: index, %value: i16) { - // CHECK: %[[ARG2_CAST:.+]] = builtin.unrealized_conversion_cast %[[ARG2]] : i16 to i32 - // CHECK: %[[ARG0_CAST:.+]] = builtin.unrealized_conversion_cast %[[ARG0]] - // CHECK: %[[ARG1_CAST:.+]] = builtin.unrealized_conversion_cast %[[ARG1]] : index to i32 + // CHECK: %[[ARG2_CAST:.+]] = unrealized_conversion_cast %[[ARG2]] : i16 to i32 + // CHECK: %[[ARG0_CAST:.+]] = unrealized_conversion_cast %[[ARG0]] + // CHECK: %[[ARG1_CAST:.+]] = unrealized_conversion_cast %[[ARG1]] : index to i32 // CHECK: %[[ZERO:.+]] = spv.Constant 0 : i32 // CHECK: %[[OFFSET:.+]] = spv.Constant 0 : i32 // CHECK: %[[ONE:.+]] = spv.Constant 1 : i32 @@ -350,8 +350,8 @@ // CHECK-LABEL: @store_i8 // CHECK: (%[[ARG0:.+]]: {{.*}}, %[[ARG1:.+]]: i8) func @store_i8(%arg0: memref, %value: i8) { - // CHECK: %[[ARG1_CAST:.+]] = builtin.unrealized_conversion_cast %[[ARG1]] : i8 to i32 - // CHECK: %[[ARG0_CAST:.+]] = builtin.unrealized_conversion_cast %[[ARG0]] + // CHECK: %[[ARG1_CAST:.+]] = unrealized_conversion_cast %[[ARG1]] : i8 to i32 + // CHECK: %[[ARG0_CAST:.+]] = unrealized_conversion_cast %[[ARG0]] // CHECK: %[[ZERO:.+]] = spv.Constant 0 : i32 // CHECK: %[[FOUR:.+]] = spv.Constant 4 : i32 // CHECK: %[[EIGHT:.+]] = spv.Constant 8 : i32 diff --git a/mlir/test/Conversion/TosaToLinalg/tosa-to-linalg.mlir b/mlir/test/Conversion/TosaToLinalg/tosa-to-linalg.mlir --- a/mlir/test/Conversion/TosaToLinalg/tosa-to-linalg.mlir +++ b/mlir/test/Conversion/TosaToLinalg/tosa-to-linalg.mlir @@ -788,7 +788,7 @@ // CHECK-DAG: [[MAXLT:%.+]] = cmpi slt, [[CMAX]], [[SCALED_ZEROED]] // CHECK-DAG: [[BOUNDED:%.+]] = select [[MAXLT]], [[CMAX]], [[LOWER]] // CHECK-DAG: [[TRUNC:%.+]] = trunci [[BOUNDED]] - // CHECK-DAG: [[CAST:%.+]] = builtin.unrealized_conversion_cast [[TRUNC]] : i8 to ui8 + // CHECK-DAG: [[CAST:%.+]] = unrealized_conversion_cast [[TRUNC]] : i8 to ui8 // CHECK: linalg.yield [[CAST]] %1 = "tosa.rescale"(%arg0) {input_zp = 17 : i32, output_zp = 22 : i32, multiplier = [19689 : i32], shift = [15 : i32], scale32 = false, double_round = false, per_channel = false} : (tensor<2xi8>) -> (tensor<2xui8>) @@ -809,7 +809,7 @@ // CHECK: ^bb0([[IN:%.+]]: ui8, [[UNUSED:%.+]]: i8): // CHECK: [[C17:%.+]] = constant 17 // CHECK: [[C22:%.+]] = constant 22 - // CHECK-DAG: [[CAST:%.+]] = builtin.unrealized_conversion_cast [[IN]] : ui8 to i8 + // CHECK-DAG: [[CAST:%.+]] = unrealized_conversion_cast [[IN]] : ui8 to i8 // CHECK-DAG: [[IN32:%.+]] = zexti [[CAST]] // CHECK-DAG: [[IN_ZEROED:%.+]] = subi [[IN32]], [[C17]] // CHECK-DAG: [[SCALED:%.+]] = "tosa.apply_scale"([[IN_ZEROED]], [[C0]], [[C1]]) {double_round = false} diff --git a/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir b/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir --- a/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir +++ b/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir @@ -30,7 +30,7 @@ // CHECK-LABEL: @bitcast_index_to_i8_vector // CHECK-SAME: %[[input:.*]]: vector<16xindex> -// CHECK: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[input]] : vector<16xindex> to vector<16xi64> +// CHECK: %[[T0:.*]] = unrealized_conversion_cast %[[input]] : vector<16xindex> to vector<16xi64> // CHECK: llvm.bitcast %[[T0]] : vector<16xi64> to vector<128xi8> // ----- @@ -96,11 +96,11 @@ // CHECK-LABEL: @broadcast_vec2d_from_vec1d( // CHECK-SAME: %[[A:.*]]: vector<2xf32>) // CHECK: %[[T0:.*]] = constant dense<0.000000e+00> : vector<3x2xf32> -// CHECK: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[T0]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> +// CHECK: %[[T1:.*]] = unrealized_conversion_cast %[[T0]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> // CHECK: %[[T2:.*]] = llvm.insertvalue %[[A]], %[[T1]][0] : !llvm.array<3 x vector<2xf32>> // CHECK: %[[T3:.*]] = llvm.insertvalue %[[A]], %[[T2]][1] : !llvm.array<3 x vector<2xf32>> // CHECK: %[[T4:.*]] = llvm.insertvalue %[[A]], %[[T3]][2] : !llvm.array<3 x vector<2xf32>> -// CHECK: %[[T5:.*]] = builtin.unrealized_conversion_cast %[[T4]] : !llvm.array<3 x vector<2xf32>> to vector<3x2xf32> +// CHECK: %[[T5:.*]] = unrealized_conversion_cast %[[T4]] : !llvm.array<3 x vector<2xf32>> to vector<3x2xf32> // CHECK: return %[[T5]] : vector<3x2xf32> // ----- @@ -112,11 +112,11 @@ // CHECK-LABEL: @broadcast_vec2d_from_index_vec1d( // CHECK-SAME: %[[A:.*]]: vector<2xindex>) // CHECK: %[[T0:.*]] = constant dense<0> : vector<3x2xindex> -// CHECK: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<2xindex> to vector<2xi64> -// CHECK: %[[T2:.*]] = builtin.unrealized_conversion_cast %[[T0]] : vector<3x2xindex> to !llvm.array<3 x vector<2xi64>> +// CHECK: %[[T1:.*]] = unrealized_conversion_cast %[[A]] : vector<2xindex> to vector<2xi64> +// CHECK: %[[T2:.*]] = unrealized_conversion_cast %[[T0]] : vector<3x2xindex> to !llvm.array<3 x vector<2xi64>> // CHECK: %[[T3:.*]] = llvm.insertvalue %[[T1]], %[[T2]][0] : !llvm.array<3 x vector<2xi64>> -// CHECK: %[[T4:.*]] = builtin.unrealized_conversion_cast %{{.*}} : !llvm.array<3 x vector<2xi64>> to vector<3x2xindex> +// CHECK: %[[T4:.*]] = unrealized_conversion_cast %{{.*}} : !llvm.array<3 x vector<2xi64>> to vector<3x2xindex> // CHECK: return %[[T4]] : vector<3x2xindex> // ----- @@ -130,18 +130,18 @@ // CHECK: %[[T0:.*]] = constant dense<0.000000e+00> : vector<3x2xf32> // CHECK: %[[T1:.*]] = constant dense<0.000000e+00> : vector<4x3x2xf32> -// CHECK: %[[T2:.*]] = builtin.unrealized_conversion_cast %[[T0]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> +// CHECK: %[[T2:.*]] = unrealized_conversion_cast %[[T0]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> // CHECK: %[[T3:.*]] = llvm.insertvalue %[[A]], %[[T2]][0] : !llvm.array<3 x vector<2xf32>> // CHECK: %[[T4:.*]] = llvm.insertvalue %[[A]], %[[T3]][1] : !llvm.array<3 x vector<2xf32>> // CHECK: %[[T5:.*]] = llvm.insertvalue %[[A]], %[[T4]][2] : !llvm.array<3 x vector<2xf32>> -// CHECK: %[[T6:.*]] = builtin.unrealized_conversion_cast %[[T1]] : vector<4x3x2xf32> to !llvm.array<4 x array<3 x vector<2xf32>>> +// CHECK: %[[T6:.*]] = unrealized_conversion_cast %[[T1]] : vector<4x3x2xf32> to !llvm.array<4 x array<3 x vector<2xf32>>> // CHECK: %[[T7:.*]] = llvm.insertvalue %[[T5]], %[[T6]][0] : !llvm.array<4 x array<3 x vector<2xf32>>> // CHECK: %[[T8:.*]] = llvm.insertvalue %[[T5]], %[[T7]][1] : !llvm.array<4 x array<3 x vector<2xf32>>> // CHECK: %[[T9:.*]] = llvm.insertvalue %[[T5]], %[[T8]][2] : !llvm.array<4 x array<3 x vector<2xf32>>> // CHECK: %[[T10:.*]] = llvm.insertvalue %[[T5]], %[[T9]][3] : !llvm.array<4 x array<3 x vector<2xf32>>> -// CHECK: %[[T11:.*]] = builtin.unrealized_conversion_cast %[[T10]] : !llvm.array<4 x array<3 x vector<2xf32>>> to vector<4x3x2xf32> +// CHECK: %[[T11:.*]] = unrealized_conversion_cast %[[T10]] : !llvm.array<4 x array<3 x vector<2xf32>>> to vector<4x3x2xf32> // CHECK: return %[[T11]] : vector<4x3x2xf32> // ----- @@ -153,16 +153,16 @@ // CHECK-LABEL: @broadcast_vec3d_from_vec2d( // CHECK-SAME: %[[A:.*]]: vector<3x2xf32>) // CHECK: %[[T0:.*]] = constant dense<0.000000e+00> : vector<4x3x2xf32> -// CHECK: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> -// CHECK: %[[T2:.*]] = builtin.unrealized_conversion_cast %[[T0]] : vector<4x3x2xf32> to !llvm.array<4 x array<3 x vector<2xf32>>> +// CHECK: %[[T1:.*]] = unrealized_conversion_cast %[[A]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> +// CHECK: %[[T2:.*]] = unrealized_conversion_cast %[[T0]] : vector<4x3x2xf32> to !llvm.array<4 x array<3 x vector<2xf32>>> // CHECK: %[[T3:.*]] = llvm.insertvalue %[[T1]], %[[T2]][0] : !llvm.array<4 x array<3 x vector<2xf32>>> -// CHECK: %[[T4:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> +// CHECK: %[[T4:.*]] = unrealized_conversion_cast %[[A]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> // CHECK: %[[T5:.*]] = llvm.insertvalue %[[T4]], %[[T3]][1] : !llvm.array<4 x array<3 x vector<2xf32>>> -// CHECK: %[[T6:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> +// CHECK: %[[T6:.*]] = unrealized_conversion_cast %[[A]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> // CHECK: %[[T7:.*]] = llvm.insertvalue %[[T6]], %[[T5]][2] : !llvm.array<4 x array<3 x vector<2xf32>>> -// CHECK: %[[T8:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> +// CHECK: %[[T8:.*]] = unrealized_conversion_cast %[[A]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> // CHECK: %[[T9:.*]] = llvm.insertvalue %[[T8]], %[[T7]][3] : !llvm.array<4 x array<3 x vector<2xf32>>> -// CHECK: %[[T10:.*]] = builtin.unrealized_conversion_cast %[[T9]] : !llvm.array<4 x array<3 x vector<2xf32>>> to vector<4x3x2xf32> +// CHECK: %[[T10:.*]] = unrealized_conversion_cast %[[T9]] : !llvm.array<4 x array<3 x vector<2xf32>>> to vector<4x3x2xf32> // CHECK: return %[[T10]] : vector<4x3x2xf32> @@ -188,13 +188,13 @@ // CHECK-LABEL: @broadcast_stretch_at_start( // CHECK-SAME: %[[A:.*]]: vector<1x4xf32>) // CHECK: %[[T1:.*]] = constant dense<0.000000e+00> : vector<3x4xf32> -// CHECK: %[[T2:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<1x4xf32> to !llvm.array<1 x vector<4xf32>> +// CHECK: %[[T2:.*]] = unrealized_conversion_cast %[[A]] : vector<1x4xf32> to !llvm.array<1 x vector<4xf32>> // CHECK: %[[T3:.*]] = llvm.extractvalue %[[T2]][0] : !llvm.array<1 x vector<4xf32>> -// CHECK: %[[T4:.*]] = builtin.unrealized_conversion_cast %[[T1]] : vector<3x4xf32> to !llvm.array<3 x vector<4xf32>> +// CHECK: %[[T4:.*]] = unrealized_conversion_cast %[[T1]] : vector<3x4xf32> to !llvm.array<3 x vector<4xf32>> // CHECK: %[[T5:.*]] = llvm.insertvalue %[[T3]], %[[T4]][0] : !llvm.array<3 x vector<4xf32>> // CHECK: %[[T6:.*]] = llvm.insertvalue %[[T3]], %[[T5]][1] : !llvm.array<3 x vector<4xf32>> // CHECK: %[[T7:.*]] = llvm.insertvalue %[[T3]], %[[T6]][2] : !llvm.array<3 x vector<4xf32>> -// CHECK: %[[T8:.*]] = builtin.unrealized_conversion_cast %[[T7]] : !llvm.array<3 x vector<4xf32>> to vector<3x4xf32> +// CHECK: %[[T8:.*]] = unrealized_conversion_cast %[[T7]] : !llvm.array<3 x vector<4xf32>> to vector<3x4xf32> // CHECK: return %[[T8]] : vector<3x4xf32> // ----- @@ -206,32 +206,32 @@ // CHECK-LABEL: @broadcast_stretch_at_end( // CHECK-SAME: %[[A:.*]]: vector<4x1xf32>) // CHECK: %[[T1:.*]] = constant dense<0.000000e+00> : vector<4x3xf32> -// CHECK: %[[T2:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<4x1xf32> to !llvm.array<4 x vector<1xf32>> +// CHECK: %[[T2:.*]] = unrealized_conversion_cast %[[A]] : vector<4x1xf32> to !llvm.array<4 x vector<1xf32>> // CHECK: %[[T3:.*]] = llvm.extractvalue %[[T2]][0] : !llvm.array<4 x vector<1xf32>> // CHECK: %[[T4:.*]] = llvm.mlir.constant(0 : i64) : i64 // CHECK: %[[T5:.*]] = llvm.extractelement %[[T3]]{{\[}}%[[T4]] : i64] : vector<1xf32> // CHECK: %[[T6:.*]] = splat %[[T5]] : vector<3xf32> -// CHECK: %[[T7:.*]] = builtin.unrealized_conversion_cast %[[T1]] : vector<4x3xf32> to !llvm.array<4 x vector<3xf32>> +// CHECK: %[[T7:.*]] = unrealized_conversion_cast %[[T1]] : vector<4x3xf32> to !llvm.array<4 x vector<3xf32>> // CHECK: %[[T8:.*]] = llvm.insertvalue %[[T6]], %[[T7]][0] : !llvm.array<4 x vector<3xf32>> -// CHECK: %[[T9:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<4x1xf32> to !llvm.array<4 x vector<1xf32>> +// CHECK: %[[T9:.*]] = unrealized_conversion_cast %[[A]] : vector<4x1xf32> to !llvm.array<4 x vector<1xf32>> // CHECK: %[[T10:.*]] = llvm.extractvalue %[[T9]][1] : !llvm.array<4 x vector<1xf32>> // CHECK: %[[T11:.*]] = llvm.mlir.constant(0 : i64) : i64 // CHECK: %[[T12:.*]] = llvm.extractelement %[[T10]]{{\[}}%[[T11]] : i64] : vector<1xf32> // CHECK: %[[T13:.*]] = splat %[[T12]] : vector<3xf32> // CHECK: %[[T14:.*]] = llvm.insertvalue %[[T13]], %[[T8]][1] : !llvm.array<4 x vector<3xf32>> -// CHECK: %[[T15:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<4x1xf32> to !llvm.array<4 x vector<1xf32>> +// CHECK: %[[T15:.*]] = unrealized_conversion_cast %[[A]] : vector<4x1xf32> to !llvm.array<4 x vector<1xf32>> // CHECK: %[[T16:.*]] = llvm.extractvalue %[[T15]][2] : !llvm.array<4 x vector<1xf32>> // CHECK: %[[T17:.*]] = llvm.mlir.constant(0 : i64) : i64 // CHECK: %[[T18:.*]] = llvm.extractelement %[[T16]]{{\[}}%[[T17]] : i64] : vector<1xf32> // CHECK: %[[T19:.*]] = splat %[[T18]] : vector<3xf32> // CHECK: %[[T20:.*]] = llvm.insertvalue %[[T19]], %[[T14]][2] : !llvm.array<4 x vector<3xf32>> -// CHECK: %[[T21:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<4x1xf32> to !llvm.array<4 x vector<1xf32>> +// CHECK: %[[T21:.*]] = unrealized_conversion_cast %[[A]] : vector<4x1xf32> to !llvm.array<4 x vector<1xf32>> // CHECK: %[[T22:.*]] = llvm.extractvalue %[[T21]][3] : !llvm.array<4 x vector<1xf32>> // CHECK: %[[T23:.*]] = llvm.mlir.constant(0 : i64) : i64 // CHECK: %[[T24:.*]] = llvm.extractelement %[[T22]]{{\[}}%[[T23]] : i64] : vector<1xf32> // CHECK: %[[T25:.*]] = splat %[[T24]] : vector<3xf32> // CHECK: %[[T26:.*]] = llvm.insertvalue %[[T25]], %[[T20]][3] : !llvm.array<4 x vector<3xf32>> -// CHECK: %[[T27:.*]] = builtin.unrealized_conversion_cast %[[T26]] : !llvm.array<4 x vector<3xf32>> to vector<4x3xf32> +// CHECK: %[[T27:.*]] = unrealized_conversion_cast %[[T26]] : !llvm.array<4 x vector<3xf32>> to vector<4x3xf32> // CHECK: return %[[T27]] : vector<4x3xf32> // ----- @@ -244,36 +244,36 @@ // CHECK-SAME: %[[A:.*]]: vector<4x1x2xf32>) -> vector<4x3x2xf32> { // CHECK: %[[T1:.*]] = constant dense<0.000000e+00> : vector<4x3x2xf32> // CHECK: %[[T2:.*]] = constant dense<0.000000e+00> : vector<3x2xf32> -// CHECK: %[[T3:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<4x1x2xf32> to !llvm.array<4 x array<1 x vector<2xf32>>> +// CHECK: %[[T3:.*]] = unrealized_conversion_cast %[[A]] : vector<4x1x2xf32> to !llvm.array<4 x array<1 x vector<2xf32>>> // CHECK: %[[T4:.*]] = llvm.extractvalue %[[T3]][0, 0] : !llvm.array<4 x array<1 x vector<2xf32>>> -// CHECK: %[[T5:.*]] = builtin.unrealized_conversion_cast %[[T2]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> +// CHECK: %[[T5:.*]] = unrealized_conversion_cast %[[T2]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> // CHECK: %[[T6:.*]] = llvm.insertvalue %[[T4]], %[[T5]][0] : !llvm.array<3 x vector<2xf32>> // CHECK: %[[T7:.*]] = llvm.insertvalue %[[T4]], %[[T6]][1] : !llvm.array<3 x vector<2xf32>> // CHECK: %[[T8:.*]] = llvm.insertvalue %[[T4]], %[[T7]][2] : !llvm.array<3 x vector<2xf32>> -// CHECK: %[[T9:.*]] = builtin.unrealized_conversion_cast %[[T1]] : vector<4x3x2xf32> to !llvm.array<4 x array<3 x vector<2xf32>>> +// CHECK: %[[T9:.*]] = unrealized_conversion_cast %[[T1]] : vector<4x3x2xf32> to !llvm.array<4 x array<3 x vector<2xf32>>> // CHECK: %[[T10:.*]] = llvm.insertvalue %[[T8]], %[[T9]][0] : !llvm.array<4 x array<3 x vector<2xf32>>> -// CHECK: %[[T11:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<4x1x2xf32> to !llvm.array<4 x array<1 x vector<2xf32>>> +// CHECK: %[[T11:.*]] = unrealized_conversion_cast %[[A]] : vector<4x1x2xf32> to !llvm.array<4 x array<1 x vector<2xf32>>> // CHECK: %[[T12:.*]] = llvm.extractvalue %[[T11]][1, 0] : !llvm.array<4 x array<1 x vector<2xf32>>> -// CHECK: %[[T13:.*]] = builtin.unrealized_conversion_cast %[[T2]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> +// CHECK: %[[T13:.*]] = unrealized_conversion_cast %[[T2]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> // CHECK: %[[T14:.*]] = llvm.insertvalue %[[T12]], %[[T13]][0] : !llvm.array<3 x vector<2xf32>> // CHECK: %[[T15:.*]] = llvm.insertvalue %[[T12]], %[[T14]][1] : !llvm.array<3 x vector<2xf32>> // CHECK: %[[T16:.*]] = llvm.insertvalue %[[T12]], %[[T15]][2] : !llvm.array<3 x vector<2xf32>> // CHECK: %[[T17:.*]] = llvm.insertvalue %[[T16]], %[[T10]][1] : !llvm.array<4 x array<3 x vector<2xf32>>> -// CHECK: %[[T18:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<4x1x2xf32> to !llvm.array<4 x array<1 x vector<2xf32>>> +// CHECK: %[[T18:.*]] = unrealized_conversion_cast %[[A]] : vector<4x1x2xf32> to !llvm.array<4 x array<1 x vector<2xf32>>> // CHECK: %[[T19:.*]] = llvm.extractvalue %[[T18]][2, 0] : !llvm.array<4 x array<1 x vector<2xf32>>> -// CHECK: %[[T20:.*]] = builtin.unrealized_conversion_cast %[[T2]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> +// CHECK: %[[T20:.*]] = unrealized_conversion_cast %[[T2]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> // CHECK: %[[T21:.*]] = llvm.insertvalue %[[T19]], %[[T20]][0] : !llvm.array<3 x vector<2xf32>> // CHECK: %[[T22:.*]] = llvm.insertvalue %[[T19]], %[[T21]][1] : !llvm.array<3 x vector<2xf32>> // CHECK: %[[T23:.*]] = llvm.insertvalue %[[T19]], %[[T22]][2] : !llvm.array<3 x vector<2xf32>> // CHECK: %[[T24:.*]] = llvm.insertvalue %[[T23]], %[[T17]][2] : !llvm.array<4 x array<3 x vector<2xf32>>> -// CHECK: %[[T25:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<4x1x2xf32> to !llvm.array<4 x array<1 x vector<2xf32>>> +// CHECK: %[[T25:.*]] = unrealized_conversion_cast %[[A]] : vector<4x1x2xf32> to !llvm.array<4 x array<1 x vector<2xf32>>> // CHECK: %[[T26:.*]] = llvm.extractvalue %[[T25]][3, 0] : !llvm.array<4 x array<1 x vector<2xf32>>> -// CHECK: %[[T27:.*]] = builtin.unrealized_conversion_cast %[[T2]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> +// CHECK: %[[T27:.*]] = unrealized_conversion_cast %[[T2]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> // CHECK: %[[T28:.*]] = llvm.insertvalue %[[T26]], %[[T27]][0] : !llvm.array<3 x vector<2xf32>> // CHECK: %[[T29:.*]] = llvm.insertvalue %[[T26]], %[[T28]][1] : !llvm.array<3 x vector<2xf32>> // CHECK: %[[T30:.*]] = llvm.insertvalue %[[T26]], %[[T29]][2] : !llvm.array<3 x vector<2xf32>> // CHECK: %[[T31:.*]] = llvm.insertvalue %[[T30]], %[[T24]][3] : !llvm.array<4 x array<3 x vector<2xf32>>> -// CHECK: %[[T32:.*]] = builtin.unrealized_conversion_cast %[[T31]] : !llvm.array<4 x array<3 x vector<2xf32>>> to vector<4x3x2xf32> +// CHECK: %[[T32:.*]] = unrealized_conversion_cast %[[T31]] : !llvm.array<4 x array<3 x vector<2xf32>>> to vector<4x3x2xf32> // CHECK: return %[[T32]] : vector<4x3x2xf32> // ----- @@ -290,14 +290,14 @@ // CHECK: %[[T4:.*]] = llvm.extractelement %[[A]]{{\[}}%[[T3]] : i64] : vector<2xf32> // CHECK: %[[T5:.*]] = splat %[[T4]] : vector<3xf32> // CHECK: %[[T6:.*]] = mulf %[[T5]], %[[B]] : vector<3xf32> -// CHECK: %[[T7:.*]] = builtin.unrealized_conversion_cast %[[T2]] : vector<2x3xf32> to !llvm.array<2 x vector<3xf32>> +// CHECK: %[[T7:.*]] = unrealized_conversion_cast %[[T2]] : vector<2x3xf32> to !llvm.array<2 x vector<3xf32>> // CHECK: %[[T8:.*]] = llvm.insertvalue %[[T6]], %[[T7]][0] : !llvm.array<2 x vector<3xf32>> // CHECK: %[[T9:.*]] = llvm.mlir.constant(1 : i64) : i64 // CHECK: %[[T10:.*]] = llvm.extractelement %[[A]]{{\[}}%[[T9]] : i64] : vector<2xf32> // CHECK: %[[T11:.*]] = splat %[[T10]] : vector<3xf32> // CHECK: %[[T12:.*]] = mulf %[[T11]], %[[B]] : vector<3xf32> // CHECK: %[[T13:.*]] = llvm.insertvalue %[[T12]], %[[T8]][1] : !llvm.array<2 x vector<3xf32>> -// CHECK: %[[T14:.*]] = builtin.unrealized_conversion_cast %[[T13]] : !llvm.array<2 x vector<3xf32>> to vector<2x3xf32> +// CHECK: %[[T14:.*]] = unrealized_conversion_cast %[[T13]] : !llvm.array<2 x vector<3xf32>> to vector<2x3xf32> // CHECK: return %[[T14]] : vector<2x3xf32> // ----- @@ -310,14 +310,14 @@ // CHECK-SAME: %[[A:.*]]: vector<2xindex>, // CHECK-SAME: %[[B:.*]]: vector<3xindex>) // CHECK: %[[T0:.*]] = constant dense<0> : vector<2x3xindex> -// CHECK: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<2xindex> to vector<2xi64> +// CHECK: %[[T1:.*]] = unrealized_conversion_cast %[[A]] : vector<2xindex> to vector<2xi64> // CHECK: %[[T2:.*]] = llvm.mlir.constant(0 : i64) : i64 // CHECK: %[[T3:.*]] = llvm.extractelement %[[T1]]{{\[}}%[[T2]] : i64] : vector<2xi64> -// CHECK: %[[T4:.*]] = builtin.unrealized_conversion_cast %[[T3]] : i64 to index +// CHECK: %[[T4:.*]] = unrealized_conversion_cast %[[T3]] : i64 to index // CHECK: %[[T5:.*]] = splat %[[T4]] : vector<3xindex> // CHECK: %[[T6:.*]] = muli %[[T5]], %[[B]] : vector<3xindex> -// CHECK: %[[T7:.*]] = builtin.unrealized_conversion_cast %[[T6]] : vector<3xindex> to vector<3xi64> -// CHECK: %[[T8:.*]] = builtin.unrealized_conversion_cast %[[T0]] : vector<2x3xindex> to !llvm.array<2 x vector<3xi64>> +// CHECK: %[[T7:.*]] = unrealized_conversion_cast %[[T6]] : vector<3xindex> to vector<3xi64> +// CHECK: %[[T8:.*]] = unrealized_conversion_cast %[[T0]] : vector<2x3xindex> to !llvm.array<2 x vector<3xi64>> // CHECK: %{{.*}} = llvm.insertvalue %[[T7]], %[[T8]][0] : !llvm.array<2 x vector<3xi64>> // ----- @@ -334,19 +334,19 @@ // CHECK: %[[T4:.*]] = llvm.mlir.constant(0 : i64) : i64 // CHECK: %[[T5:.*]] = llvm.extractelement %[[A]]{{\[}}%[[T4]] : i64] : vector<2xf32> // CHECK: %[[T6:.*]] = splat %[[T5]] : vector<3xf32> -// CHECK: %[[T7:.*]] = builtin.unrealized_conversion_cast %[[C]] : vector<2x3xf32> to !llvm.array<2 x vector<3xf32>> +// CHECK: %[[T7:.*]] = unrealized_conversion_cast %[[C]] : vector<2x3xf32> to !llvm.array<2 x vector<3xf32>> // CHECK: %[[T8:.*]] = llvm.extractvalue %[[T7]][0] : !llvm.array<2 x vector<3xf32>> // CHECK: %[[T9:.*]] = "llvm.intr.fmuladd"(%[[T6]], %[[B]], %[[T8]]) : (vector<3xf32>, vector<3xf32>, vector<3xf32>) -> vector<3xf32> -// CHECK: %[[T10:.*]] = builtin.unrealized_conversion_cast %[[T3]] : vector<2x3xf32> to !llvm.array<2 x vector<3xf32>> +// CHECK: %[[T10:.*]] = unrealized_conversion_cast %[[T3]] : vector<2x3xf32> to !llvm.array<2 x vector<3xf32>> // CHECK: %[[T11:.*]] = llvm.insertvalue %[[T9]], %[[T10]][0] : !llvm.array<2 x vector<3xf32>> // CHECK: %[[T12:.*]] = llvm.mlir.constant(1 : i64) : i64 // CHECK: %[[T13:.*]] = llvm.extractelement %[[A]]{{\[}}%[[T12]] : i64] : vector<2xf32> // CHECK: %[[T14:.*]] = splat %[[T13]] : vector<3xf32> -// CHECK: %[[T15:.*]] = builtin.unrealized_conversion_cast %[[C]] : vector<2x3xf32> to !llvm.array<2 x vector<3xf32>> +// CHECK: %[[T15:.*]] = unrealized_conversion_cast %[[C]] : vector<2x3xf32> to !llvm.array<2 x vector<3xf32>> // CHECK: %[[T16:.*]] = llvm.extractvalue %[[T15]][1] : !llvm.array<2 x vector<3xf32>> // CHECK: %[[T17:.*]] = "llvm.intr.fmuladd"(%[[T14]], %[[B]], %[[T16]]) : (vector<3xf32>, vector<3xf32>, vector<3xf32>) -> vector<3xf32> // CHECK: %[[T18:.*]] = llvm.insertvalue %[[T17]], %[[T11]][1] : !llvm.array<2 x vector<3xf32>> -// CHECK: %[[T19:.*]] = builtin.unrealized_conversion_cast %[[T18]] : !llvm.array<2 x vector<3xf32>> to vector<2x3xf32> +// CHECK: %[[T19:.*]] = unrealized_conversion_cast %[[T18]] : !llvm.array<2 x vector<3xf32>> to vector<2x3xf32> // CHECK: return %[[T19]] : vector<2x3xf32> // ----- @@ -370,10 +370,10 @@ // CHECK-LABEL: @shuffle_1D_index_direct( // CHECK-SAME: %[[A:.*]]: vector<2xindex>, // CHECK-SAME: %[[B:.*]]: vector<2xindex>) -// CHECK: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<2xindex> to vector<2xi64> -// CHECK: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<2xindex> to vector<2xi64> +// CHECK: %[[T0:.*]] = unrealized_conversion_cast %[[A]] : vector<2xindex> to vector<2xi64> +// CHECK: %[[T1:.*]] = unrealized_conversion_cast %[[B]] : vector<2xindex> to vector<2xi64> // CHECK: %[[T2:.*]] = llvm.shufflevector %[[T0]], %[[T1]] [0, 1] : vector<2xi64>, vector<2xi64> -// CHECK: %[[T3:.*]] = builtin.unrealized_conversion_cast %[[T2]] : vector<2xi64> to vector<2xindex> +// CHECK: %[[T3:.*]] = unrealized_conversion_cast %[[T2]] : vector<2xi64> to vector<2xindex> // CHECK: return %[[T3]] : vector<2xindex> // ----- @@ -417,8 +417,8 @@ // CHECK-LABEL: @shuffle_2D( // CHECK-SAME: %[[A:.*]]: vector<1x4xf32>, // CHECK-SAME: %[[B:.*]]: vector<2x4xf32>) -// CHECK: %[[VAL_0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<1x4xf32> to !llvm.array<1 x vector<4xf32>> -// CHECK: %[[VAL_1:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> +// CHECK: %[[VAL_0:.*]] = unrealized_conversion_cast %[[A]] : vector<1x4xf32> to !llvm.array<1 x vector<4xf32>> +// CHECK: %[[VAL_1:.*]] = unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> // CHECK: %[[u0:.*]] = llvm.mlir.undef : !llvm.array<3 x vector<4xf32>> // CHECK: %[[e1:.*]] = llvm.extractvalue %[[VAL_1]][0] : !llvm.array<2 x vector<4xf32>> // CHECK: %[[i1:.*]] = llvm.insertvalue %[[e1]], %[[u0]][0] : !llvm.array<3 x vector<4xf32>> @@ -426,7 +426,7 @@ // CHECK: %[[i2:.*]] = llvm.insertvalue %[[e2]], %[[i1]][1] : !llvm.array<3 x vector<4xf32>> // CHECK: %[[e3:.*]] = llvm.extractvalue %[[VAL_1]][1] : !llvm.array<2 x vector<4xf32>> // CHECK: %[[i3:.*]] = llvm.insertvalue %[[e3]], %[[i2]][2] : !llvm.array<3 x vector<4xf32>> -// CHECK: %[[VAL_3:.*]] = builtin.unrealized_conversion_cast %[[i3]] : !llvm.array<3 x vector<4xf32>> to vector<3x4xf32> +// CHECK: %[[VAL_3:.*]] = unrealized_conversion_cast %[[i3]] : !llvm.array<3 x vector<4xf32>> to vector<3x4xf32> // CHECK: return %[[VAL_3]] : vector<3x4xf32> // ----- @@ -461,10 +461,10 @@ } // CHECK-LABEL: @extract_index_element_from_vec_1d( // CHECK-SAME: %[[A:.*]]: vector<16xindex>) -// CHECK: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<16xindex> to vector<16xi64> +// CHECK: %[[T0:.*]] = unrealized_conversion_cast %[[A]] : vector<16xindex> to vector<16xi64> // CHECK: %[[T1:.*]] = llvm.mlir.constant(15 : i64) : i64 // CHECK: %[[T2:.*]] = llvm.extractelement %[[T0]][%[[T1]] : i64] : vector<16xi64> -// CHECK: %[[T3:.*]] = builtin.unrealized_conversion_cast %[[T2]] : i64 to index +// CHECK: %[[T3:.*]] = unrealized_conversion_cast %[[T2]] : i64 to index // CHECK: return %[[T3]] : index // ----- @@ -533,11 +533,11 @@ // CHECK-LABEL: @insert_index_element_into_vec_1d( // CHECK-SAME: %[[A:.*]]: index, // CHECK-SAME: %[[B:.*]]: vector<4xindex>) -// CHECK: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : index to i64 -// CHECK: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<4xindex> to vector<4xi64> +// CHECK: %[[T0:.*]] = unrealized_conversion_cast %[[A]] : index to i64 +// CHECK: %[[T1:.*]] = unrealized_conversion_cast %[[B]] : vector<4xindex> to vector<4xi64> // CHECK: %[[T3:.*]] = llvm.mlir.constant(3 : i64) : i64 // CHECK: %[[T4:.*]] = llvm.insertelement %[[T0]], %[[T1]][%[[T3]] : i64] : vector<4xi64> -// CHECK: %[[T5:.*]] = builtin.unrealized_conversion_cast %[[T4]] : vector<4xi64> to vector<4xindex> +// CHECK: %[[T5:.*]] = unrealized_conversion_cast %[[T4]] : vector<4xi64> to vector<4xindex> // CHECK: return %[[T5]] : vector<4xindex> // ----- @@ -598,9 +598,9 @@ } // CHECK-LABEL: @vector_index_type_cast( // CHECK-SAME: %[[A:.*]]: memref<8x8x8xindex>) -// CHECK: %{{.*}} = builtin.unrealized_conversion_cast %[[A]] : memref<8x8x8xindex> to !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> +// CHECK: %{{.*}} = unrealized_conversion_cast %[[A]] : memref<8x8x8xindex> to !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> -// CHECK: %{{.*}} = builtin.unrealized_conversion_cast %{{.*}} : !llvm.struct<(ptr>>>, ptr>>>, i64)> to memref> +// CHECK: %{{.*}} = unrealized_conversion_cast %{{.*}} : !llvm.struct<(ptr>>>, ptr>>>, i64)> to memref> // ----- @@ -654,7 +654,7 @@ } // CHECK-LABEL: @vector_print_scalar_si4( // CHECK-SAME: %[[A:.*]]: si4) -// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : si4 to i4 +// CHECK: %[[C:.*]] = unrealized_conversion_cast %[[A]] : si4 to i4 // CHECK: %[[S:.*]] = sexti %[[C]] : i4 to i64 // CHECK: llvm.call @printI64(%[[S]]) : (i64) -> () // CHECK: llvm.call @printNewline() : () -> () @@ -667,7 +667,7 @@ } // CHECK-LABEL: @vector_print_scalar_ui4( // CHECK-SAME: %[[A:.*]]: ui4) -// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : ui4 to i4 +// CHECK: %[[C:.*]] = unrealized_conversion_cast %[[A]] : ui4 to i4 // CHECK: %[[S:.*]] = zexti %[[C]] : i4 to i64 // CHECK: llvm.call @printU64(%[[S]]) : (i64) -> () // CHECK: llvm.call @printNewline() : () -> () @@ -692,7 +692,7 @@ } // CHECK-LABEL: @vector_print_scalar_ui32( // CHECK-SAME: %[[A:.*]]: ui32) -// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : ui32 to i32 +// CHECK: %[[C:.*]] = unrealized_conversion_cast %[[A]] : ui32 to i32 // CHECK: %[[S:.*]] = zexti %[[C]] : i32 to i64 // CHECK: llvm.call @printU64(%[[S]]) : (i64) -> () @@ -716,7 +716,7 @@ } // CHECK-LABEL: @vector_print_scalar_si40( // CHECK-SAME: %[[A:.*]]: si40) -// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : si40 to i40 +// CHECK: %[[C:.*]] = unrealized_conversion_cast %[[A]] : si40 to i40 // CHECK: %[[S:.*]] = sexti %[[C]] : i40 to i64 // CHECK: llvm.call @printI64(%[[S]]) : (i64) -> () // CHECK: llvm.call @printNewline() : () -> () @@ -729,7 +729,7 @@ } // CHECK-LABEL: @vector_print_scalar_ui40( // CHECK-SAME: %[[A:.*]]: ui40) -// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : ui40 to i40 +// CHECK: %[[C:.*]] = unrealized_conversion_cast %[[A]] : ui40 to i40 // CHECK: %[[S:.*]] = zexti %[[C]] : i40 to i64 // CHECK: llvm.call @printU64(%[[S]]) : (i64) -> () // CHECK: llvm.call @printNewline() : () -> () @@ -753,7 +753,7 @@ } // CHECK-LABEL: @vector_print_scalar_ui64( // CHECK-SAME: %[[A:.*]]: ui64) -// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : ui64 to i64 +// CHECK: %[[C:.*]] = unrealized_conversion_cast %[[A]] : ui64 to i64 // CHECK: llvm.call @printU64(%[[C]]) : (i64) -> () // CHECK: llvm.call @printNewline() : () -> () @@ -765,7 +765,7 @@ } // CHECK-LABEL: @vector_print_scalar_index( // CHECK-SAME: %[[A:.*]]: index) -// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : index to i64 +// CHECK: %[[C:.*]] = unrealized_conversion_cast %[[A]] : index to i64 // CHECK: llvm.call @printU64(%[[C]]) : (i64) -> () // CHECK: llvm.call @printNewline() : () -> () @@ -799,7 +799,7 @@ } // CHECK-LABEL: @vector_print_vector( // CHECK-SAME: %[[A:.*]]: vector<2x2xf32>) -// CHECK: %[[VAL_1:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<2x2xf32> to !llvm.array<2 x vector<2xf32>> +// CHECK: %[[VAL_1:.*]] = unrealized_conversion_cast %[[A]] : vector<2x2xf32> to !llvm.array<2 x vector<2xf32>> // CHECK: llvm.call @printOpen() : () -> () // CHECK: %[[x0:.*]] = llvm.extractvalue %[[VAL_1]][0] : !llvm.array<2 x vector<2xf32>> // CHECK: llvm.call @printOpen() : () -> () @@ -844,10 +844,10 @@ } // CHECK-LABEL: @extract_strided_index_slice1( // CHECK-SAME: %[[A:.*]]: vector<4xindex>) -// CHECK: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<4xindex> to vector<4xi64> -// CHECK: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<4xindex> to vector<4xi64> +// CHECK: %[[T0:.*]] = unrealized_conversion_cast %[[A]] : vector<4xindex> to vector<4xi64> +// CHECK: %[[T1:.*]] = unrealized_conversion_cast %[[A]] : vector<4xindex> to vector<4xi64> // CHECK: %[[T2:.*]] = llvm.shufflevector %[[T0]], %[[T1]] [2, 3] : vector<4xi64>, vector<4xi64> -// CHECK: %[[T3:.*]] = builtin.unrealized_conversion_cast %[[T2]] : vector<2xi64> to vector<2xindex> +// CHECK: %[[T3:.*]] = unrealized_conversion_cast %[[T2]] : vector<2xi64> to vector<2xindex> // CHECK: return %[[T3]] : vector<2xindex> // ----- @@ -858,13 +858,13 @@ } // CHECK-LABEL: @extract_strided_slice2( // CHECK-SAME: %[[ARG:.*]]: vector<4x8xf32>) -// CHECK: %[[A:.*]] = builtin.unrealized_conversion_cast %[[ARG]] : vector<4x8xf32> to !llvm.array<4 x vector<8xf32>> +// CHECK: %[[A:.*]] = unrealized_conversion_cast %[[ARG]] : vector<4x8xf32> to !llvm.array<4 x vector<8xf32>> // CHECK: %[[T0:.*]] = llvm.mlir.undef : !llvm.array<2 x vector<8xf32>> // CHECK: %[[T1:.*]] = llvm.extractvalue %[[A]][2] : !llvm.array<4 x vector<8xf32>> // CHECK: %[[T2:.*]] = llvm.insertvalue %[[T1]], %[[T0]][0] : !llvm.array<2 x vector<8xf32>> // CHECK: %[[T3:.*]] = llvm.extractvalue %[[A]][3] : !llvm.array<4 x vector<8xf32>> // CHECK: %[[T4:.*]] = llvm.insertvalue %[[T3]], %[[T2]][1] : !llvm.array<2 x vector<8xf32>> -// CHECK: %[[T5:.*]] = builtin.unrealized_conversion_cast %[[T4]] : !llvm.array<2 x vector<8xf32>> to vector<2x8xf32> +// CHECK: %[[T5:.*]] = unrealized_conversion_cast %[[T4]] : !llvm.array<2 x vector<8xf32>> to vector<2x8xf32> // CHECK: return %[[T5]] // ----- @@ -877,16 +877,16 @@ // CHECK-SAME: %[[ARG:.*]]: vector<4x8xf32>) // CHECK: %[[VAL_1:.*]] = constant 0.000000e+00 : f32 // CHECK: %[[VAL_2:.*]] = splat %[[VAL_1]] : vector<2x2xf32> -// CHECK: %[[A:.*]] = builtin.unrealized_conversion_cast %[[ARG]] : vector<4x8xf32> to !llvm.array<4 x vector<8xf32>> +// CHECK: %[[A:.*]] = unrealized_conversion_cast %[[ARG]] : vector<4x8xf32> to !llvm.array<4 x vector<8xf32>> // CHECK: %[[T2:.*]] = llvm.extractvalue %[[A]][2] : !llvm.array<4 x vector<8xf32>> // CHECK: %[[T3:.*]] = llvm.shufflevector %[[T2]], %[[T2]] [2, 3] : vector<8xf32>, vector<8xf32> -// CHECK: %[[VAL_6:.*]] = builtin.unrealized_conversion_cast %[[VAL_2]] : vector<2x2xf32> to !llvm.array<2 x vector<2xf32>> +// CHECK: %[[VAL_6:.*]] = unrealized_conversion_cast %[[VAL_2]] : vector<2x2xf32> to !llvm.array<2 x vector<2xf32>> // CHECK: %[[T4:.*]] = llvm.insertvalue %[[T3]], %[[VAL_6]][0] : !llvm.array<2 x vector<2xf32>> -// CHECK: %[[A:.*]] = builtin.unrealized_conversion_cast %[[ARG]] : vector<4x8xf32> to !llvm.array<4 x vector<8xf32>> +// CHECK: %[[A:.*]] = unrealized_conversion_cast %[[ARG]] : vector<4x8xf32> to !llvm.array<4 x vector<8xf32>> // CHECK: %[[T5:.*]] = llvm.extractvalue %[[A]][3] : !llvm.array<4 x vector<8xf32>> // CHECK: %[[T6:.*]] = llvm.shufflevector %[[T5]], %[[T5]] [2, 3] : vector<8xf32>, vector<8xf32> // CHECK: %[[T7:.*]] = llvm.insertvalue %[[T6]], %[[T4]][1] : !llvm.array<2 x vector<2xf32>> -// CHECK: %[[VAL_12:.*]] = builtin.unrealized_conversion_cast %[[T7]] : !llvm.array<2 x vector<2xf32>> to vector<2x2xf32> +// CHECK: %[[VAL_12:.*]] = unrealized_conversion_cast %[[T7]] : !llvm.array<2 x vector<2xf32>> to vector<2x2xf32> // CHECK: return %[[VAL_12]] : vector<2x2xf32> // ----- @@ -968,69 +968,69 @@ // CHECK-LABEL: @insert_strided_slice3( // CHECK-SAME: %[[A:.*]]: vector<2x4xf32>, // CHECK-SAME: %[[B:.*]]: vector<16x4x8xf32>) -// CHECK: %[[s2:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<16x4x8xf32> to !llvm.array<16 x array<4 x vector<8xf32>>> +// CHECK: %[[s2:.*]] = unrealized_conversion_cast %[[B]] : vector<16x4x8xf32> to !llvm.array<16 x array<4 x vector<8xf32>>> // CHECK: %[[s3:.*]] = llvm.extractvalue %[[s2]][0] : !llvm.array<16 x array<4 x vector<8xf32>>> -// CHECK: %[[s4:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> +// CHECK: %[[s4:.*]] = unrealized_conversion_cast %[[A]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> // CHECK: %[[s5:.*]] = llvm.extractvalue %[[s4]][0] : !llvm.array<2 x vector<4xf32>> -// CHECK: %[[s6:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<16x4x8xf32> to !llvm.array<16 x array<4 x vector<8xf32>>> +// CHECK: %[[s6:.*]] = unrealized_conversion_cast %[[B]] : vector<16x4x8xf32> to !llvm.array<16 x array<4 x vector<8xf32>>> // CHECK: %[[s7:.*]] = llvm.extractvalue %[[s6]][0, 0] : !llvm.array<16 x array<4 x vector<8xf32>>> // CHECK: %[[s8:.*]] = constant 0 : index -// CHECK: %[[s9:.*]] = builtin.unrealized_conversion_cast %[[s8]] : index to i64 +// CHECK: %[[s9:.*]] = unrealized_conversion_cast %[[s8]] : index to i64 // CHECK: %[[s10:.*]] = llvm.extractelement %[[s5]]{{\[}}%[[s9]] : i64] : vector<4xf32> // CHECK: %[[s11:.*]] = constant 2 : index -// CHECK: %[[s12:.*]] = builtin.unrealized_conversion_cast %[[s11]] : index to i64 +// CHECK: %[[s12:.*]] = unrealized_conversion_cast %[[s11]] : index to i64 // CHECK: %[[s13:.*]] = llvm.insertelement %[[s10]], %[[s7]]{{\[}}%[[s12]] : i64] : vector<8xf32> // CHECK: %[[s14:.*]] = constant 1 : index -// CHECK: %[[s15:.*]] = builtin.unrealized_conversion_cast %[[s14]] : index to i64 +// CHECK: %[[s15:.*]] = unrealized_conversion_cast %[[s14]] : index to i64 // CHECK: %[[s16:.*]] = llvm.extractelement %[[s5]]{{\[}}%[[s15]] : i64] : vector<4xf32> // CHECK: %[[s17:.*]] = constant 3 : index -// CHECK: %[[s18:.*]] = builtin.unrealized_conversion_cast %[[s17]] : index to i64 +// CHECK: %[[s18:.*]] = unrealized_conversion_cast %[[s17]] : index to i64 // CHECK: %[[s19:.*]] = llvm.insertelement %[[s16]], %[[s13]]{{\[}}%[[s18]] : i64] : vector<8xf32> // CHECK: %[[s20:.*]] = constant 2 : index -// CHECK: %[[s21:.*]] = builtin.unrealized_conversion_cast %[[s20]] : index to i64 +// CHECK: %[[s21:.*]] = unrealized_conversion_cast %[[s20]] : index to i64 // CHECK: %[[s22:.*]] = llvm.extractelement %[[s5]]{{\[}}%[[s21]] : i64] : vector<4xf32> // CHECK: %[[s23:.*]] = constant 4 : index -// CHECK: %[[s24:.*]] = builtin.unrealized_conversion_cast %[[s23]] : index to i64 +// CHECK: %[[s24:.*]] = unrealized_conversion_cast %[[s23]] : index to i64 // CHECK: %[[s25:.*]] = llvm.insertelement %[[s22]], %[[s19]]{{\[}}%[[s24]] : i64] : vector<8xf32> // CHECK: %[[s26:.*]] = constant 3 : index -// CHECK: %[[s27:.*]] = builtin.unrealized_conversion_cast %[[s26]] : index to i64 +// CHECK: %[[s27:.*]] = unrealized_conversion_cast %[[s26]] : index to i64 // CHECK: %[[s28:.*]] = llvm.extractelement %[[s5]]{{\[}}%[[s27]] : i64] : vector<4xf32> // CHECK: %[[s29:.*]] = constant 5 : index -// CHECK: %[[s30:.*]] = builtin.unrealized_conversion_cast %[[s29]] : index to i64 +// CHECK: %[[s30:.*]] = unrealized_conversion_cast %[[s29]] : index to i64 // CHECK: %[[s31:.*]] = llvm.insertelement %[[s28]], %[[s25]]{{\[}}%[[s30]] : i64] : vector<8xf32> // CHECK: %[[s32:.*]] = llvm.insertvalue %[[s31]], %[[s3]][0] : !llvm.array<4 x vector<8xf32>> -// CHECK: %[[s33:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> +// CHECK: %[[s33:.*]] = unrealized_conversion_cast %[[A]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> // CHECK: %[[s34:.*]] = llvm.extractvalue %[[s33]][1] : !llvm.array<2 x vector<4xf32>> -// CHECK: %[[s35:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<16x4x8xf32> to !llvm.array<16 x array<4 x vector<8xf32>>> +// CHECK: %[[s35:.*]] = unrealized_conversion_cast %[[B]] : vector<16x4x8xf32> to !llvm.array<16 x array<4 x vector<8xf32>>> // CHECK: %[[s36:.*]] = llvm.extractvalue %[[s35]][0, 1] : !llvm.array<16 x array<4 x vector<8xf32>>> // CHECK: %[[s37:.*]] = constant 0 : index -// CHECK: %[[s38:.*]] = builtin.unrealized_conversion_cast %[[s37]] : index to i64 +// CHECK: %[[s38:.*]] = unrealized_conversion_cast %[[s37]] : index to i64 // CHECK: %[[s39:.*]] = llvm.extractelement %[[s34]]{{\[}}%[[s38]] : i64] : vector<4xf32> // CHECK: %[[s40:.*]] = constant 2 : index -// CHECK: %[[s41:.*]] = builtin.unrealized_conversion_cast %[[s40]] : index to i64 +// CHECK: %[[s41:.*]] = unrealized_conversion_cast %[[s40]] : index to i64 // CHECK: %[[s42:.*]] = llvm.insertelement %[[s39]], %[[s36]]{{\[}}%[[s41]] : i64] : vector<8xf32> // CHECK: %[[s43:.*]] = constant 1 : index -// CHECK: %[[s44:.*]] = builtin.unrealized_conversion_cast %[[s43]] : index to i64 +// CHECK: %[[s44:.*]] = unrealized_conversion_cast %[[s43]] : index to i64 // CHECK: %[[s45:.*]] = llvm.extractelement %[[s34]]{{\[}}%[[s44]] : i64] : vector<4xf32> // CHECK: %[[s46:.*]] = constant 3 : index -// CHECK: %[[s47:.*]] = builtin.unrealized_conversion_cast %[[s46]] : index to i64 +// CHECK: %[[s47:.*]] = unrealized_conversion_cast %[[s46]] : index to i64 // CHECK: %[[s48:.*]] = llvm.insertelement %[[s45]], %[[s42]]{{\[}}%[[s47]] : i64] : vector<8xf32> // CHECK: %[[s49:.*]] = constant 2 : index -// CHECK: %[[s50:.*]] = builtin.unrealized_conversion_cast %[[s49]] : index to i64 +// CHECK: %[[s50:.*]] = unrealized_conversion_cast %[[s49]] : index to i64 // CHECK: %[[s51:.*]] = llvm.extractelement %[[s34]]{{\[}}%[[s50]] : i64] : vector<4xf32> // CHECK: %[[s52:.*]] = constant 4 : index -// CHECK: %[[s53:.*]] = builtin.unrealized_conversion_cast %[[s52]] : index to i64 +// CHECK: %[[s53:.*]] = unrealized_conversion_cast %[[s52]] : index to i64 // CHECK: %[[s54:.*]] = llvm.insertelement %[[s51]], %[[s48]]{{\[}}%[[s53]] : i64] : vector<8xf32> // CHECK: %[[s55:.*]] = constant 3 : index -// CHECK: %[[s56:.*]] = builtin.unrealized_conversion_cast %[[s55]] : index to i64 +// CHECK: %[[s56:.*]] = unrealized_conversion_cast %[[s55]] : index to i64 // CHECK: %[[s57:.*]] = llvm.extractelement %[[s34]]{{\[}}%[[s56]] : i64] : vector<4xf32> // CHECK: %[[s58:.*]] = constant 5 : index -// CHECK: %[[s59:.*]] = builtin.unrealized_conversion_cast %[[s58]] : index to i64 +// CHECK: %[[s59:.*]] = unrealized_conversion_cast %[[s58]] : index to i64 // CHECK: %[[s60:.*]] = llvm.insertelement %[[s57]], %[[s54]]{{\[}}%[[s59]] : i64] : vector<8xf32> // CHECK: %[[s61:.*]] = llvm.insertvalue %[[s60]], %[[s32]][1] : !llvm.array<4 x vector<8xf32>> -// CHECK: %[[s62:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<16x4x8xf32> to !llvm.array<16 x array<4 x vector<8xf32>>> +// CHECK: %[[s62:.*]] = unrealized_conversion_cast %[[B]] : vector<16x4x8xf32> to !llvm.array<16 x array<4 x vector<8xf32>>> // CHECK: %[[s63:.*]] = llvm.insertvalue %[[s61]], %[[s62]][0] : !llvm.array<16 x array<4 x vector<8xf32>>> -// CHECK: %[[s64:.*]] = builtin.unrealized_conversion_cast %[[s63]] : !llvm.array<16 x array<4 x vector<8xf32>>> to vector<16x4x8xf32> +// CHECK: %[[s64:.*]] = unrealized_conversion_cast %[[s63]] : !llvm.array<16 x array<4 x vector<8xf32>>> to vector<16x4x8xf32> // CHECK: return %[[s64]] : vector<16x4x8xf32> // ----- @@ -1043,20 +1043,20 @@ // CHECK-SAME: (vector<8xf32>, vector<8xf32>, vector<8xf32>) -> vector<8xf32> %0 = vector.fma %a, %a, %a : vector<8xf32> - // CHECK: %[[BL:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> + // CHECK: %[[BL:.*]] = unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> // CHECK: %[[b00:.*]] = llvm.extractvalue %[[BL]][0] : !llvm.array<2 x vector<4xf32>> - // CHECK: %[[BL:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> + // CHECK: %[[BL:.*]] = unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> // CHECK: %[[b01:.*]] = llvm.extractvalue %[[BL]][0] : !llvm.array<2 x vector<4xf32>> - // CHECK: %[[BL:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> + // CHECK: %[[BL:.*]] = unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> // CHECK: %[[b02:.*]] = llvm.extractvalue %[[BL]][0] : !llvm.array<2 x vector<4xf32>> // CHECK: %[[B0:.*]] = "llvm.intr.fmuladd"(%[[b00]], %[[b01]], %[[b02]]) : // CHECK-SAME: (vector<4xf32>, vector<4xf32>, vector<4xf32>) -> vector<4xf32> // CHECK: llvm.insertvalue %[[B0]], {{.*}}[0] : !llvm.array<2 x vector<4xf32>> - // CHECK: %[[BL:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> + // CHECK: %[[BL:.*]] = unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> // CHECK: %[[b10:.*]] = llvm.extractvalue %[[BL]][1] : !llvm.array<2 x vector<4xf32>> - // CHECK: %[[BL:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> + // CHECK: %[[BL:.*]] = unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> // CHECK: %[[b11:.*]] = llvm.extractvalue %[[BL]][1] : !llvm.array<2 x vector<4xf32>> - // CHECK: %[[BL:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> + // CHECK: %[[BL:.*]] = unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> // CHECK: %[[b12:.*]] = llvm.extractvalue %[[BL]][1] : !llvm.array<2 x vector<4xf32>> // CHECK: %[[B1:.*]] = "llvm.intr.fmuladd"(%[[b10]], %[[b11]], %[[b12]]) : // CHECK-SAME: (vector<4xf32>, vector<4xf32>, vector<4xf32>) -> vector<4xf32> @@ -1146,9 +1146,9 @@ } // CHECK-LABEL: @reduce_index( // CHECK-SAME: %[[A:.*]]: vector<16xindex>) -// CHECK: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<16xindex> to vector<16xi64> +// CHECK: %[[T0:.*]] = unrealized_conversion_cast %[[A]] : vector<16xindex> to vector<16xi64> // CHECK: %[[T1:.*]] = "llvm.intr.vector.reduce.add"(%[[T0]]) -// CHECK: %[[T2:.*]] = builtin.unrealized_conversion_cast %[[T1]] : i64 to index +// CHECK: %[[T2:.*]] = unrealized_conversion_cast %[[T1]] : i64 to index // CHECK: return %[[T2]] : index // 4x16 16x3 4x3 @@ -1267,7 +1267,7 @@ // CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: index) -> vector<17xindex> // CHECK: %[[C7:.*]] = constant 7 : index // CHECK: %[[SPLAT:.*]] = splat %[[C7]] : vector<17xindex> -// CHECK: %{{.*}} = builtin.unrealized_conversion_cast %[[SPLAT]] : vector<17xindex> to vector<17xi64> +// CHECK: %{{.*}} = unrealized_conversion_cast %[[SPLAT]] : vector<17xindex> to vector<17xi64> // CHECK: %[[loaded:.*]] = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : // CHECK-SAME: (!llvm.ptr>, vector<17xi1>, vector<17xi64>) -> vector<17xi64> @@ -1404,10 +1404,10 @@ // CHECK-LABEL: func @genbool_2d // CHECK: %[[VAL_0:.*]] = constant dense<[true, true, false, false]> : vector<4xi1> // CHECK: %[[VAL_1:.*]] = constant dense : vector<4x4xi1> -// CHECK: %[[VAL_2:.*]] = builtin.unrealized_conversion_cast %[[VAL_1]] : vector<4x4xi1> to !llvm.array<4 x vector<4xi1>> +// CHECK: %[[VAL_2:.*]] = unrealized_conversion_cast %[[VAL_1]] : vector<4x4xi1> to !llvm.array<4 x vector<4xi1>> // CHECK: %[[VAL_3:.*]] = llvm.insertvalue %[[VAL_0]], %[[VAL_2]][0] : !llvm.array<4 x vector<4xi1>> // CHECK: %[[VAL_4:.*]] = llvm.insertvalue %[[VAL_0]], %[[VAL_3]][1] : !llvm.array<4 x vector<4xi1>> -// CHECK: %[[VAL_5:.*]] = builtin.unrealized_conversion_cast %[[VAL_4]] : !llvm.array<4 x vector<4xi1>> to vector<4x4xi1> +// CHECK: %[[VAL_5:.*]] = unrealized_conversion_cast %[[VAL_4]] : !llvm.array<4 x vector<4xi1>> to vector<4x4xi1> // CHECK: return %[[VAL_5]] : vector<4x4xi1> // ----- @@ -1434,11 +1434,11 @@ } // CHECK-LABEL: func @flat_transpose_index // CHECK-SAME: %[[A:.*]]: vector<16xindex> -// CHECK: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<16xindex> to vector<16xi64> +// CHECK: %[[T0:.*]] = unrealized_conversion_cast %[[A]] : vector<16xindex> to vector<16xi64> // CHECK: %[[T1:.*]] = llvm.intr.matrix.transpose %[[T0]] // CHECK-SAME: {columns = 4 : i32, rows = 4 : i32} : // CHECK-SAME: vector<16xi64> into vector<16xi64> -// CHECK: %[[T2:.*]] = builtin.unrealized_conversion_cast %[[T1]] : vector<16xi64> to vector<16xindex> +// CHECK: %[[T2:.*]] = unrealized_conversion_cast %[[T1]] : vector<16xi64> to vector<16xindex> // CHECK: return %[[T2]] : vector<16xindex> // ----- @@ -1464,7 +1464,7 @@ } // CHECK-LABEL: func @vector_load_op_index // CHECK: %[[T0:.*]] = llvm.load %{{.*}} {alignment = 8 : i64} : !llvm.ptr> -// CHECK: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[T0]] : vector<8xi64> to vector<8xindex> +// CHECK: %[[T1:.*]] = unrealized_conversion_cast %[[T0]] : vector<8xi64> to vector<8xindex> // CHECK: return %[[T1]] : vector<8xindex> // ----- @@ -1536,7 +1536,7 @@ // CHECK-LABEL: func @masked_load_op // CHECK: %[[CO:.*]] = constant 0 : index -// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[CO]] : index to i64 +// CHECK: %[[C:.*]] = unrealized_conversion_cast %[[CO]] : index to i64 // CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr, i64) -> !llvm.ptr // CHECK: %[[B:.*]] = llvm.bitcast %[[P]] : !llvm.ptr to !llvm.ptr> // CHECK: %[[L:.*]] = llvm.intr.masked.load %[[B]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (!llvm.ptr>, vector<16xi1>, vector<16xf32>) -> vector<16xf32> @@ -1562,7 +1562,7 @@ // CHECK-LABEL: func @masked_store_op // CHECK: %[[CO:.*]] = constant 0 : index -// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[CO]] : index to i64 +// CHECK: %[[C:.*]] = unrealized_conversion_cast %[[CO]] : index to i64 // CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr, i64) -> !llvm.ptr // CHECK: %[[B:.*]] = llvm.bitcast %[[P]] : !llvm.ptr to !llvm.ptr> // CHECK: llvm.intr.masked.store %{{.*}}, %[[B]], %{{.*}} {alignment = 4 : i32} : vector<16xf32>, vector<16xi1> into !llvm.ptr> @@ -1601,7 +1601,7 @@ // CHECK-LABEL: func @gather_op_index // CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, vector<3xi64>) -> !llvm.vec<3 x ptr> // CHECK: %[[G:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : (!llvm.vec<3 x ptr>, vector<3xi1>, vector<3xi64>) -> vector<3xi64> -// CHECK: %{{.*}} = builtin.unrealized_conversion_cast %[[G]] : vector<3xi64> to vector<3xindex> +// CHECK: %{{.*}} = unrealized_conversion_cast %[[G]] : vector<3xi64> to vector<3xindex> // ----- @@ -1691,7 +1691,7 @@ // CHECK-LABEL: func @expand_load_op // CHECK: %[[CO:.*]] = constant 0 : index -// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[CO]] : index to i64 +// CHECK: %[[C:.*]] = unrealized_conversion_cast %[[CO]] : index to i64 // CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr, i64) -> !llvm.ptr // CHECK: %[[E:.*]] = "llvm.intr.masked.expandload"(%[[P]], %{{.*}}, %{{.*}}) : (!llvm.ptr, vector<11xi1>, vector<11xf32>) -> vector<11xf32> // CHECK: return %[[E]] : vector<11xf32> @@ -1716,7 +1716,7 @@ // CHECK-LABEL: func @compress_store_op // CHECK: %[[CO:.*]] = constant 0 : index -// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[CO]] : index to i64 +// CHECK: %[[C:.*]] = unrealized_conversion_cast %[[CO]] : index to i64 // CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr, i64) -> !llvm.ptr // CHECK: "llvm.intr.masked.compressstore"(%{{.*}}, %[[P]], %{{.*}}) : (vector<11xf32>, !llvm.ptr, vector<11xi1>) -> () diff --git a/mlir/test/Dialect/ArmSVE/memcpy.mlir b/mlir/test/Dialect/ArmSVE/memcpy.mlir --- a/mlir/test/Dialect/ArmSVE/memcpy.mlir +++ b/mlir/test/Dialect/ArmSVE/memcpy.mlir @@ -9,15 +9,15 @@ // CHECK: scf.for [[LOOPIDX:%arg[0-9]+]] = {{.*}} scf.for %i0 = %c0 to %size step %step { - // CHECK: [[SRCMRS:%[0-9]+]] = builtin.unrealized_conversion_cast [[SRC]] : memref to !llvm.struct<(ptr - // CHECK: [[SRCIDX:%[0-9]+]] = builtin.unrealized_conversion_cast [[LOOPIDX]] : index to i64 + // CHECK: [[SRCMRS:%[0-9]+]] = unrealized_conversion_cast [[SRC]] : memref to !llvm.struct<(ptr + // CHECK: [[SRCIDX:%[0-9]+]] = unrealized_conversion_cast [[LOOPIDX]] : index to i64 // CHECK: [[SRCMEM:%[0-9]+]] = llvm.extractvalue [[SRCMRS]][1] : !llvm.struct<(ptr // CHECK-NEXT: [[SRCPTR:%[0-9]+]] = llvm.getelementptr [[SRCMEM]]{{.}}[[SRCIDX]]{{.}} : (!llvm.ptr, i64) -> !llvm.ptr // CHECK-NEXT: [[SRCVPTR:%[0-9]+]] = llvm.bitcast [[SRCPTR]] : !llvm.ptr to !llvm.ptr> // CHECK-NEXT: [[LDVAL:%[0-9]+]] = llvm.load [[SRCVPTR]] : !llvm.ptr> %0 = arm_sve.load %src[%i0] : !arm_sve.vector<4xf32> from memref - // CHECK: [[DSTMRS:%[0-9]+]] = builtin.unrealized_conversion_cast [[DST]] : memref to !llvm.struct<(ptr - // CHECK: [[DSTIDX:%[0-9]+]] = builtin.unrealized_conversion_cast [[LOOPIDX]] : index to i64 + // CHECK: [[DSTMRS:%[0-9]+]] = unrealized_conversion_cast [[DST]] : memref to !llvm.struct<(ptr + // CHECK: [[DSTIDX:%[0-9]+]] = unrealized_conversion_cast [[LOOPIDX]] : index to i64 // CHECK: [[DSTMEM:%[0-9]+]] = llvm.extractvalue [[DSTMRS]][1] : !llvm.struct<(ptr // CHECK-NEXT: [[DSTPTR:%[0-9]+]] = llvm.getelementptr [[DSTMEM]]{{.}}[[DSTIDX]]{{.}} : (!llvm.ptr, i64) -> !llvm.ptr // CHECK-NEXT: [[DSTVPTR:%[0-9]+]] = llvm.bitcast [[DSTPTR]] : !llvm.ptr to !llvm.ptr> diff --git a/mlir/test/Dialect/Linalg/reshape_control_fusion.mlir b/mlir/test/Dialect/Linalg/reshape_control_fusion.mlir --- a/mlir/test/Dialect/Linalg/reshape_control_fusion.mlir +++ b/mlir/test/Dialect/Linalg/reshape_control_fusion.mlir @@ -20,7 +20,7 @@ } // CHECK-DAG: #[[MAP0:.+]] = affine_map<(d0, d1) -> (d0, d1)> // CHECK-DAG: #[[MAP1:.+]] = affine_map<(d0, d1) -> (d1)> -// CHECK: builtin.func @control_producer_reshape_fusion +// CHECK: func @control_producer_reshape_fusion // CHECK-SAME: %[[ARG0:[a-zA-Z0-9_]+]]: tensor // CHECK-SAME: %[[ARG1:[a-zA-Z0-9_]+]]: tensor // CHECK-DAG: %[[C0:.+]] = constant 0 : index @@ -54,7 +54,7 @@ return %1 : tensor<1x?x?xf32> } // CHECK-DAG: #[[MAP:.+]] = affine_map<(d0, d1, d2) -> (d0, d1, d2) -// CHECK: builtin.func @control_consumer_reshape_fusion +// CHECK: func @control_consumer_reshape_fusion // CHECK: %[[FILL:.+]] = linalg.generic // CHECK-SAME: indexing_maps = [#[[MAP]]] // CHECK-SAME: outs(%{{.+}} : tensor<1x?x?xf32>) diff --git a/mlir/test/Dialect/SparseTensor/sparse_perm.mlir b/mlir/test/Dialect/SparseTensor/sparse_perm.mlir --- a/mlir/test/Dialect/SparseTensor/sparse_perm.mlir +++ b/mlir/test/Dialect/SparseTensor/sparse_perm.mlir @@ -14,7 +14,7 @@ iterator_types = ["parallel", "parallel", "parallel"] } -// CHECK-LABEL: builtin.func @sparse_static_dims( +// CHECK-LABEL: func @sparse_static_dims( // CHECK-SAME: %[[VAL_0:.*]]: tensor<10x20x30xf32, #sparse_tensor.encoding<{{{.*}}}>>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<20x30x10xf32>) -> tensor<20x30x10xf32> { // CHECK: %[[VAL_2:.*]] = constant 20 : index @@ -52,7 +52,7 @@ return %0 : tensor<20x30x10xf32> } -// CHECK-LABEL: builtin.func @sparse_dynamic_dims( +// CHECK-LABEL: func @sparse_dynamic_dims( // CHECK-SAME: %[[VAL_0:.*]]: tensor>, // CHECK-SAME: %[[VAL_1:.*]]: tensor) -> tensor { // CHECK: %[[VAL_2:.*]] = constant 2 : index diff --git a/mlir/test/Dialect/SparseTensor/sparse_perm_lower.mlir b/mlir/test/Dialect/SparseTensor/sparse_perm_lower.mlir --- a/mlir/test/Dialect/SparseTensor/sparse_perm_lower.mlir +++ b/mlir/test/Dialect/SparseTensor/sparse_perm_lower.mlir @@ -16,7 +16,7 @@ iterator_types = ["reduction", "reduction", "reduction"] } -// CHECK-HIR-LABEL: builtin.func @sparse_dynamic_dims( +// CHECK-HIR-LABEL: func @sparse_dynamic_dims( // CHECK-HIR-SAME: %[[VAL_0:.*]]: tensor>, // CHECK-HIR-SAME: %[[VAL_1:.*]]: tensor) -> tensor { // CHECK-HIR-DAG: %[[C0:.*]] = constant 0 : index @@ -48,7 +48,7 @@ // CHECK-HIR: return %[[VAL_24]] : tensor // CHECK-HIR: } // -// CHECK-MIR-LABEL: builtin.func @sparse_dynamic_dims( +// CHECK-MIR-LABEL: func @sparse_dynamic_dims( // CHECK-MIR-SAME: %[[VAL_0:.*]]: !llvm.ptr, // CHECK-MIR-SAME: %[[VAL_1:.*]]: tensor) -> tensor { // CHECK-MIR-DAG: %[[C0:.*]] = constant 0 : index diff --git a/mlir/test/IR/invalid-ops.mlir b/mlir/test/IR/invalid-ops.mlir --- a/mlir/test/IR/invalid-ops.mlir +++ b/mlir/test/IR/invalid-ops.mlir @@ -70,7 +70,7 @@ func @unknown_custom_op() { ^bb0: - %i = crazyThing() {value = 0} : () -> index // expected-error {{custom op 'crazyThing' is unknown}} + %i = test.crazyThing() {value = 0} : () -> index // expected-error {{custom op 'test.crazyThing' is unknown}} return } diff --git a/mlir/test/IR/invalid.mlir b/mlir/test/IR/invalid.mlir --- a/mlir/test/IR/invalid.mlir +++ b/mlir/test/IR/invalid.mlir @@ -263,7 +263,7 @@ // ----- func @non_operation() { - asd // expected-error {{custom op 'asd' is unknown}} + test.asd // expected-error {{custom op 'test.asd' is unknown}} } // ----- @@ -817,7 +817,7 @@ func @f(f32) { ^bb0(%a : f32): %18 = cmpi slt, %idx, %idx : index - tensor<42 x index // expected-error {{custom op 'tensor' is unknown}} + tensor<42 x index // expected-error {{custom op 'builtin.tensor' is unknown}} return } diff --git a/mlir/test/IR/parser.mlir b/mlir/test/IR/parser.mlir --- a/mlir/test/IR/parser.mlir +++ b/mlir/test/IR/parser.mlir @@ -1307,6 +1307,28 @@ return } + +// This tests the behavior of "default dialect": +// operations like `test.default_dialect` can define a default dialect +// used in nested region. +// CHECK-LABEL: func @default_dialect +func @default_dialect() { + test.default_dialect { + // The test dialect is the default in this region, the following two + // operations are parsed identically. + // CHECK-NOT: test.parse_integer_literal + parse_integer_literal : 5 + // CHECK: parse_integer_literal : 6 + test.parse_integer_literal : 6 + // Verify that only an op prefix is stripped, not an attribute value for + // example. + // CHECK: "test.op_with_attr"() {test.attr = "test.value"} : () -> () + "test.op_with_attr"() {test.attr = "test.value"} : () -> () + "test.terminator"() : ()->() + } + return +} + // CHECK-LABEL: func @unreachable_dominance_violation_ok func @unreachable_dominance_violation_ok() -> i1 { // CHECK: [[VAL:%.*]] = constant false diff --git a/mlir/test/lib/Dialect/Test/TestOps.td b/mlir/test/lib/Dialect/Test/TestOps.td --- a/mlir/test/lib/Dialect/Test/TestOps.td +++ b/mlir/test/lib/Dialect/Test/TestOps.td @@ -626,7 +626,7 @@ // pretty printed value name. def StringAttrPrettyNameOp : TEST_Op<"string_attr_pretty_name", - [DeclareOpInterfaceMethods]> { + [DeclareOpInterfaceMethods]> { let arguments = (ins StrArrayAttr:$names); let results = (outs Variadic:$r); @@ -634,6 +634,19 @@ let parser = [{ return ::parse$cppClass(parser, result); }]; } +// This is used to test encoding of a string attribute into an SSA name of a +// pretty printed value name. +def DefaultDialectOp : TEST_Op<"default_dialect", [OpAsmOpInterface]> { + let regions = (region AnyRegion:$body); + let extraClassDeclaration = [{ + static ::llvm::StringRef getDefaultDialect() { + return "test"; + } + void getAsmResultNames(::llvm::function_ref setNameFn) {} + }]; + let assemblyFormat = "regions attr-dict-with-keyword"; +} + //===----------------------------------------------------------------------===// // Test Locations //===----------------------------------------------------------------------===//