diff --git a/flang/lib/Optimizer/Dialect/FIRType.cpp b/flang/lib/Optimizer/Dialect/FIRType.cpp --- a/flang/lib/Optimizer/Dialect/FIRType.cpp +++ b/flang/lib/Optimizer/Dialect/FIRType.cpp @@ -13,6 +13,7 @@ #include "flang/Optimizer/Dialect/FIRType.h" #include "flang/Optimizer/Dialect/FIRDialect.h" #include "mlir/IR/Builders.h" +#include "mlir/IR/BuiltinDialect.h" #include "mlir/IR/Diagnostics.h" #include "mlir/IR/DialectImplementation.h" #include "llvm/ADT/SmallPtrSet.h" @@ -188,7 +189,7 @@ } bool isa_std_type(mlir::Type t) { - return t.getDialect().getNamespace().empty(); + return llvm::isa(t.getDialect()); } bool isa_fir_or_std_type(mlir::Type t) { diff --git a/flang/test/Fir/cg-ops.fir b/flang/test/Fir/cg-ops.fir --- a/flang/test/Fir/cg-ops.fir +++ b/flang/test/Fir/cg-ops.fir @@ -1,4 +1,4 @@ -// RUN: fir-opt --pass-pipeline="func(cg-rewrite),fir.global(cg-rewrite),cse" %s | FileCheck %s +// RUN: fir-opt --pass-pipeline="builtin.func(cg-rewrite),fir.global(cg-rewrite),cse" %s | FileCheck %s // CHECK-LABEL: func @codegen( // CHECK-SAME: %[[arg:.*]]: !fir diff --git a/mlir/docs/Diagnostics.md b/mlir/docs/Diagnostics.md --- a/mlir/docs/Diagnostics.md +++ b/mlir/docs/Diagnostics.md @@ -155,7 +155,7 @@ example output is shown below: ```shell -test.mlir:3:3: error: 'module_terminator' op expects parent op 'module' +test.mlir:3:3: error: 'module_terminator' op expects parent op 'builtin.module' "module_terminator"() : () -> () ^ test.mlir:3:3: note: see current operation: "module_terminator"() : () -> () @@ -172,7 +172,7 @@ generated certain diagnostics. An example output is shown below: ```shell -test.mlir:3:3: error: 'module_terminator' op expects parent op 'module' +test.mlir:3:3: error: 'module_terminator' op expects parent op 'builtin.module' "module_terminator"() : () -> () ^ test.mlir:3:3: note: diagnostic emitted with trace: diff --git a/mlir/docs/PassManagement.md b/mlir/docs/PassManagement.md --- a/mlir/docs/PassManagement.md +++ b/mlir/docs/PassManagement.md @@ -343,7 +343,7 @@ // explicitly specific, the default is the builtin `module` operation. PassManager pm(ctx); // Note: We could also create the above `PassManager` this way. -PassManager pm(ctx, /*operationName=*/"module"); +PassManager pm(ctx, /*operationName=*/"builtin.module"); // Add a pass on the top-level module operation. pm.addPass(std::make_unique()); @@ -405,7 +405,7 @@ void MyModulePass::runOnOperation() { ModuleOp module = getOperation(); if (hasSomeSpecificProperty(module)) { - OpPassManager dynamicPM("module"); + OpPassManager dynamicPM("builtin.module"); ...; // Build the dynamic pipeline. if (failed(runPipeline(dynamicPM, module))) return signalPassFailure(); @@ -531,12 +531,12 @@ default view: ```shell -$ mlir-opt -pass-pipeline='func(my-pass,my-pass)' foo.mlir -pass-statistics +$ mlir-opt -pass-pipeline='builtin.func(my-pass,my-pass)' foo.mlir -pass-statistics ===-------------------------------------------------------------------------=== ... Pass statistics report ... ===-------------------------------------------------------------------------=== -'func' Pipeline +'builtin.func' Pipeline MyPass (S) 15 exampleStat - An example statistic VerifierPass @@ -550,7 +550,7 @@ together: ```shell -$ mlir-opt -pass-pipeline='func(my-pass, my-pass)' foo.mlir -pass-statistics -pass-statistics-display=list +$ mlir-opt -pass-pipeline='builtin.func(my-pass, my-pass)' foo.mlir -pass-statistics -pass-statistics-display=list ===-------------------------------------------------------------------------=== ... Pass statistics report ... @@ -656,7 +656,7 @@ * `op-name` * This corresponds to the mnemonic name of an operation to run passes on, - e.g. `func` or `module`. + e.g. `builtin.func` or `builtin.module`. * `pass-name` | `pass-pipeline-name` * This corresponds to the argument of a registered pass or pass pipeline, e.g. `cse` or `canonicalize`. @@ -675,7 +675,7 @@ Can also be specified as (via the `-pass-pipeline` flag): ```shell -$ mlir-opt foo.mlir -pass-pipeline='func(cse,canonicalize),convert-std-to-llvm{use-bare-ptr-memref-call-conv=1}' +$ mlir-opt foo.mlir -pass-pipeline='builtin.func(cse,canonicalize),convert-std-to-llvm{use-bare-ptr-memref-call-conv=1}' ``` In order to support round-tripping a pass to the textual representation using @@ -996,7 +996,7 @@ `-mlir-timing-display=list`. ```shell -$ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='func(cse,canonicalize)' -convert-std-to-llvm -mlir-timing -mlir-timing-display=list +$ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='builtin.func(cse,canonicalize)' -convert-std-to-llvm -mlir-timing -mlir-timing-display=list ===-------------------------------------------------------------------------=== ... Pass execution timing report ... @@ -1021,7 +1021,7 @@ invalidated and recomputed. This is the default display mode. ```shell -$ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='func(cse,canonicalize)' -convert-std-to-llvm -mlir-timing +$ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='builtin.func(cse,canonicalize)' -convert-std-to-llvm -mlir-timing ===-------------------------------------------------------------------------=== ... Pass execution timing report ... @@ -1029,7 +1029,7 @@ Total Execution Time: 0.0249 seconds ---Wall Time--- --- Name --- - 0.0058 ( 70.8%) 'func' Pipeline + 0.0058 ( 70.8%) 'builtin.func' Pipeline 0.0004 ( 4.3%) CSE 0.0002 ( 2.6%) (A) DominanceInfo 0.0004 ( 4.8%) VerifierPass @@ -1052,7 +1052,7 @@ cpu time. ```shell -$ mlir-opt foo.mlir -pass-pipeline='func(cse,canonicalize)' -convert-std-to-llvm -mlir-timing +$ mlir-opt foo.mlir -pass-pipeline='builtin.func(cse,canonicalize)' -convert-std-to-llvm -mlir-timing ===-------------------------------------------------------------------------=== ... Pass execution timing report ... @@ -1060,7 +1060,7 @@ Total Execution Time: 0.0078 seconds ---User Time--- ---Wall Time--- --- Name --- - 0.0177 ( 88.5%) 0.0057 ( 71.3%) 'func' Pipeline + 0.0177 ( 88.5%) 0.0057 ( 71.3%) 'builtin.func' Pipeline 0.0044 ( 22.0%) 0.0015 ( 18.9%) CSE 0.0029 ( 14.5%) 0.0012 ( 15.2%) (A) DominanceInfo 0.0038 ( 18.9%) 0.0015 ( 18.7%) VerifierPass @@ -1088,7 +1088,7 @@ * Print the IR before every pass in the pipeline. ```shell -$ mlir-opt foo.mlir -pass-pipeline='func(cse)' -print-ir-before=cse +$ mlir-opt foo.mlir -pass-pipeline='builtin.func(cse)' -print-ir-before=cse *** IR Dump Before CSE *** func @simple_constant() -> (i32, i32) { @@ -1104,7 +1104,7 @@ * Print the IR after every pass in the pipeline. ```shell -$ mlir-opt foo.mlir -pass-pipeline='func(cse)' -print-ir-after=cse +$ mlir-opt foo.mlir -pass-pipeline='builtin.func(cse)' -print-ir-after=cse *** IR Dump After CSE *** func @simple_constant() -> (i32, i32) { @@ -1125,7 +1125,7 @@ printing. ```shell -$ mlir-opt foo.mlir -pass-pipeline='func(cse,cse)' -print-ir-after=cse -print-ir-after-change +$ mlir-opt foo.mlir -pass-pipeline='builtin.func(cse,cse)' -print-ir-after=cse -print-ir-after-change *** IR Dump After CSE *** func @simple_constant() -> (i32, i32) { @@ -1140,7 +1140,7 @@ above. ```shell -$ mlir-opt foo.mlir -pass-pipeline='func(cse,bad-pass)' -print-ir-failure +$ mlir-opt foo.mlir -pass-pipeline='builtin.func(cse,bad-pass)' -print-ir-failure *** IR Dump After BadPass Failed *** func @simple_constant() -> (i32, i32) { @@ -1156,9 +1156,9 @@ is disabled(`-mlir-disable-threading`) ```shell -$ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='func(cse)' -print-ir-after=cse -print-ir-module-scope +$ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='builtin.func(cse)' -print-ir-after=cse -print-ir-module-scope -*** IR Dump After CSE *** ('func' operation: @bar) +*** IR Dump After CSE *** ('builtin.func' operation: @bar) func @bar(%arg0: f32, %arg1: f32) -> f32 { ... } @@ -1169,7 +1169,7 @@ return %c1_i32, %c1_i32_0 : i32, i32 } -*** IR Dump After CSE *** ('func' operation: @simple_constant) +*** IR Dump After CSE *** ('builtin.func' operation: @simple_constant) func @bar(%arg0: f32, %arg1: f32) -> f32 { ... } @@ -1193,7 +1193,7 @@ reproducible may have the form: ```mlir -// configuration: -pass-pipeline='func(cse,canonicalize),inline' -verify-each +// configuration: -pass-pipeline='builtin.func(cse,canonicalize),inline' -verify-each module { func @foo() { @@ -1228,7 +1228,7 @@ the following reproducer will be generated: ```mlir -// configuration: -pass-pipeline='func(canonicalize)' -verify-each -mlir-disable-threading +// configuration: -pass-pipeline='builtin.func(canonicalize)' -verify-each -mlir-disable-threading module { func @foo() { diff --git a/mlir/docs/SymbolsAndSymbolTables.md b/mlir/docs/SymbolsAndSymbolTables.md --- a/mlir/docs/SymbolsAndSymbolTables.md +++ b/mlir/docs/SymbolsAndSymbolTables.md @@ -31,16 +31,16 @@ within the parent `SymbolTable`. This name is semantically similarly to an SSA result value, and may be referred to by other operations to provide a symbolic link, or use, to the symbol. An example of a `Symbol` operation is -[`func`](Dialects/Builtin.md/#func-mlirfuncop). `func` defines a symbol name, which is -[referred to](#referencing-a-symbol) by operations like +[`builtin.func`](Dialects/Builtin.md/#func-mlirfuncop). `builtin.func` defines a +symbol name, which is [referred to](#referencing-a-symbol) by operations like [`std.call`](Dialects/Standard.md/#stdcall-callop). ### Defining or declaring a Symbol A `Symbol` operation should use the `SymbolOpInterface` interface to provide the -necessary verification and accessors; it also supports -operations, such as `module`, that conditionally define a symbol. `Symbol`s must -have the following properties: +necessary verification and accessors; it also supports operations, such as +`builtin.module`, that conditionally define a symbol. `Symbol`s must have the +following properties: * A `StringAttr` attribute named 'SymbolTable::getSymbolAttrName()'(`sym_name`). @@ -77,7 +77,7 @@ Below is an example of how an operation can reference a symbol operation: ```mlir -// This `func` operation defines a symbol named `symbol`. +// This `builtin.func` operation defines a symbol named `symbol`. func @symbol() // Our `foo.user` operation contains a SymbolRefAttr with the name of the @@ -106,7 +106,7 @@ // Here we define another nested symbol table, except this time it also defines // a symbol. module @module_symbol { - // This `func` operation defines a symbol named `nested_symbol`. + // This `builtin.func` operation defines a symbol named `nested_symbol`. func @nested_symbol() } diff --git a/mlir/docs/Tutorials/UnderstandingTheIRStructure.md b/mlir/docs/Tutorials/UnderstandingTheIRStructure.md --- a/mlir/docs/Tutorials/UnderstandingTheIRStructure.md +++ b/mlir/docs/Tutorials/UnderstandingTheIRStructure.md @@ -96,7 +96,7 @@ llvm-project/mlir/test/IR/print-ir-nesting.mlir`: ```mlir -"module"() ( { +"builtin.module"() ( { %0:4 = "dialect.op1"() {"attribute name" = 42 : i32} : () -> (i1, i16, i32, i64) "dialect.op2"() ( { "dialect.innerop1"(%0#0, %0#1) : (i1, i16) -> () @@ -116,7 +116,7 @@ And will yield the following output: ``` -visiting op: 'module' with 0 operands and 0 results +visiting op: 'builtin.module' with 0 operands and 0 results 1 nested regions: Region with 1 blocks: Block with 0 arguments, 0 successors, and 3 operations diff --git a/mlir/include/mlir/Dialect/PDL/IR/PDLOps.td b/mlir/include/mlir/Dialect/PDL/IR/PDLOps.td --- a/mlir/include/mlir/Dialect/PDL/IR/PDLOps.td +++ b/mlir/include/mlir/Dialect/PDL/IR/PDLOps.td @@ -342,7 +342,7 @@ ```mlir // Define an instance with single range of types. %allResultTypes = pdl.types - %op = pdl.operation "unrealized_conversion_cast" -> (%allResultTypes : !pdl.types) + %op = pdl.operation "builtin.unrealized_conversion_cast" -> (%allResultTypes : !pdl.types) ``` 2) A variadic number of either !pdl.type or !pdl.range: diff --git a/mlir/include/mlir/IR/BuiltinDialect.td b/mlir/include/mlir/IR/BuiltinDialect.td --- a/mlir/include/mlir/IR/BuiltinDialect.td +++ b/mlir/include/mlir/IR/BuiltinDialect.td @@ -20,7 +20,7 @@ let summary = "A dialect containing the builtin Attributes, Operations, and Types"; - let name = ""; + let name = "builtin"; let cppNamespace = "::mlir"; let extraClassDeclaration = [{ private: diff --git a/mlir/include/mlir/IR/Dialect.h b/mlir/include/mlir/IR/Dialect.h --- a/mlir/include/mlir/IR/Dialect.h +++ b/mlir/include/mlir/IR/Dialect.h @@ -294,7 +294,7 @@ using InterfaceMapTy = DenseMap; public: - explicit DialectRegistry() {} + explicit DialectRegistry(); template void insert() { @@ -367,8 +367,7 @@ void addOpInterface() { StringRef opName = OpTy::getOperationName(); StringRef dialectName = opName.split('.').first; - addObjectInterface(dialectName == opName ? "" : dialectName, - ModelTy::Interface::getInterfaceID(), + addObjectInterface(dialectName, ModelTy::Interface::getInterfaceID(), [](MLIRContext *context) { OpTy::template attachInterface(*context); }); diff --git a/mlir/include/mlir/Pass/PassManager.h b/mlir/include/mlir/Pass/PassManager.h --- a/mlir/include/mlir/Pass/PassManager.h +++ b/mlir/include/mlir/Pass/PassManager.h @@ -172,7 +172,7 @@ /// style. The created pass manager can schedule operations that match /// `operationName`. PassManager(MLIRContext *ctx, Nesting nesting = Nesting::Explicit, - StringRef operationName = "module"); + StringRef operationName = "builtin.module"); PassManager(MLIRContext *ctx, StringRef operationName) : PassManager(ctx, Nesting::Explicit, operationName) {} ~PassManager(); diff --git a/mlir/include/mlir/Transforms/LoopUtils.h b/mlir/include/mlir/Transforms/LoopUtils.h --- a/mlir/include/mlir/Transforms/LoopUtils.h +++ b/mlir/include/mlir/Transforms/LoopUtils.h @@ -278,7 +278,7 @@ void mapLoopToProcessorIds(scf::ForOp forOp, ArrayRef processorId, ArrayRef numProcessors); -/// Gathers all AffineForOps in 'func' grouped by loop depth. +/// Gathers all AffineForOps in 'builtin.func' grouped by loop depth. void gatherLoops(FuncOp func, std::vector> &depthToLoops); diff --git a/mlir/lib/Bindings/Python/IRCore.cpp b/mlir/lib/Bindings/Python/IRCore.cpp --- a/mlir/lib/Bindings/Python/IRCore.cpp +++ b/mlir/lib/Bindings/Python/IRCore.cpp @@ -643,11 +643,8 @@ MlirDialect PyDialects::getDialectForKey(const std::string &key, bool attrError) { - // If the "std" dialect was asked for, substitute the empty namespace :( - static const std::string emptyKey; - const std::string *canonKey = key == "std" ? &emptyKey : &key; - MlirDialect dialect = mlirContextGetOrLoadDialect( - getContext()->get(), {canonKey->data(), canonKey->size()}); + MlirDialect dialect = mlirContextGetOrLoadDialect(getContext()->get(), + {key.data(), key.size()}); if (mlirDialectIsNull(dialect)) { throw SetPyError(attrError ? PyExc_AttributeError : PyExc_IndexError, Twine("Dialect '") + key + "' not found"); diff --git a/mlir/lib/Dialect/Linalg/Transforms/ComprehensiveBufferize.cpp b/mlir/lib/Dialect/Linalg/Transforms/ComprehensiveBufferize.cpp --- a/mlir/lib/Dialect/Linalg/Transforms/ComprehensiveBufferize.cpp +++ b/mlir/lib/Dialect/Linalg/Transforms/ComprehensiveBufferize.cpp @@ -2813,7 +2813,7 @@ removeBufferizationFuncArguments(bbArg); }); - OpPassManager cleanupPipeline(OpPassManager("module")); + OpPassManager cleanupPipeline("builtin.module"); cleanupPipeline.addPass(createCanonicalizerPass()); cleanupPipeline.addPass(createCSEPass()); cleanupPipeline.addPass(createLoopInvariantCodeMotionPass()); diff --git a/mlir/lib/IR/BuiltinDialect.cpp b/mlir/lib/IR/BuiltinDialect.cpp --- a/mlir/lib/IR/BuiltinDialect.cpp +++ b/mlir/lib/IR/BuiltinDialect.cpp @@ -78,8 +78,8 @@ FuncOp FuncOp::create(Location location, StringRef name, FunctionType type, ArrayRef attrs) { - OperationState state(location, "func"); OpBuilder builder(location->getContext()); + OperationState state(location, getOperationName()); FuncOp::build(builder, state, name, type, attrs); return cast(Operation::create(state)); } diff --git a/mlir/lib/IR/BuiltinTypes.cpp b/mlir/lib/IR/BuiltinTypes.cpp --- a/mlir/lib/IR/BuiltinTypes.cpp +++ b/mlir/lib/IR/BuiltinTypes.cpp @@ -491,7 +491,7 @@ // element type within that dialect. return type.isa() || - !type.getDialect().getNamespace().empty(); + !llvm::isa(type.getDialect()); } //===----------------------------------------------------------------------===// diff --git a/mlir/lib/IR/Dialect.cpp b/mlir/lib/IR/Dialect.cpp --- a/mlir/lib/IR/Dialect.cpp +++ b/mlir/lib/IR/Dialect.cpp @@ -30,6 +30,8 @@ // DialectRegistry //===----------------------------------------------------------------------===// +DialectRegistry::DialectRegistry() { insert(); } + void DialectRegistry::addDialectInterface( StringRef dialectName, TypeID interfaceTypeID, DialectInterfaceAllocatorFunction allocator) { @@ -59,19 +61,11 @@ StringRef dialectName, TypeID interfaceTypeID, ObjectInterfaceAllocatorFunction allocator) { assert(allocator && "unexpected null interface allocation function"); + auto it = registry.find(dialectName.str()); + assert(it != registry.end() && + "adding an interface for an op from an unregistered dialect"); - // Builtin dialect has an empty prefix and is always registered. - TypeID dialectTypeID; - if (!dialectName.empty()) { - auto it = registry.find(dialectName.str()); - assert(it != registry.end() && - "adding an interface for an op from an unregistered dialect"); - dialectTypeID = it->second.first; - } else { - dialectTypeID = TypeID::get(); - } - - auto &ifaces = interfaces[dialectTypeID]; + auto &ifaces = interfaces[it->second.first]; for (const auto &kvp : ifaces.objectInterfaces) { if (kvp.first == interfaceTypeID) { LLVM_DEBUG(llvm::dbgs() @@ -185,8 +179,6 @@ /// Utility function that returns if the given string is a valid dialect /// namespace. bool Dialect::isValidNamespace(StringRef str) { - if (str.empty()) - return true; llvm::Regex dialectNameRegex("^[a-zA-Z_][a-zA-Z_0-9\\$]*$"); return dialectNameRegex.match(str); } 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 @@ -38,13 +38,12 @@ StringRef OperationName::getDialectNamespace() const { if (Dialect *dialect = getDialect()) return dialect->getNamespace(); - return representation.get().strref().split('.').first; + return getStringRef().split('.').first; } /// Return the operation name with dialect name stripped, if it has one. StringRef OperationName::stripDialect() const { - auto splitName = getStringRef().split("."); - return splitName.second.empty() ? splitName.first : splitName.second; + return getStringRef().split('.').second; } /// Return the name of this operation. This always succeeds. 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 @@ -730,7 +730,7 @@ // We create these placeholders as having an empty name, which we know // cannot be created through normal user input, allowing us to distinguish // them. - auto name = OperationName("unrealized_conversion_cast", getContext()); + auto name = OperationName("builtin.unrealized_conversion_cast", getContext()); auto *op = Operation::create( getEncodedSourceLocation(loc), name, type, /*operands=*/{}, /*attributes=*/llvm::None, /*successors=*/{}, /*numRegions=*/0); @@ -1857,16 +1857,17 @@ 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 standard - // operation and prefix it with "std". - // TODO: Would it be better to just build a mapping of the registered - // operations in the standard dialect? - if (getContext()->getOrLoadDialect("std")) { + // 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 (!opDefinition && getContext()->getOrLoadDialect("std")) { opDefinition = AbstractOperation::lookup(Twine("std." + opName).str(), getContext()); - if (opDefinition) - opName = opDefinition->name.strref(); } + if (opDefinition) + opName = opDefinition->name.strref(); } } diff --git a/mlir/lib/Pass/PassRegistry.cpp b/mlir/lib/Pass/PassRegistry.cpp --- a/mlir/lib/Pass/PassRegistry.cpp +++ b/mlir/lib/Pass/PassRegistry.cpp @@ -271,9 +271,9 @@ /// /// A pipeline is defined as a series of names, each of which may in itself /// recursively contain a nested pipeline. A name is either the name of a pass - /// (e.g. "cse") or the name of an operation type (e.g. "func"). If the name - /// is the name of a pass, the InnerPipeline is empty, since passes cannot - /// contain inner pipelines. + /// (e.g. "cse") or the name of an operation type (e.g. "builtin.func"). If + /// the name is the name of a pass, the InnerPipeline is empty, since passes + /// cannot contain inner pipelines. struct PipelineElement { PipelineElement(StringRef name) : name(name), registryEntry(nullptr) {} diff --git a/mlir/lib/Transforms/Utils/LoopUtils.cpp b/mlir/lib/Transforms/Utils/LoopUtils.cpp --- a/mlir/lib/Transforms/Utils/LoopUtils.cpp +++ b/mlir/lib/Transforms/Utils/LoopUtils.cpp @@ -2940,7 +2940,7 @@ } } -/// Gathers all AffineForOps in 'func' grouped by loop depth. +/// Gathers all AffineForOps in 'builtin.func' grouped by loop depth. void mlir::gatherLoops(FuncOp func, std::vector> &depthToLoops) { for (auto &block : func) diff --git a/mlir/test/Analysis/test-alias-analysis-modref.mlir b/mlir/test/Analysis/test-alias-analysis-modref.mlir --- a/mlir/test/Analysis/test-alias-analysis-modref.mlir +++ b/mlir/test/Analysis/test-alias-analysis-modref.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt %s -pass-pipeline='func(test-alias-analysis-modref)' -split-input-file -allow-unregistered-dialect 2>&1 | FileCheck %s +// RUN: mlir-opt %s -pass-pipeline='builtin.func(test-alias-analysis-modref)' -split-input-file -allow-unregistered-dialect 2>&1 | FileCheck %s // CHECK-LABEL: Testing : "no_side_effects" // CHECK: alloc -> func.region0#0: NoModRef diff --git a/mlir/test/Analysis/test-alias-analysis.mlir b/mlir/test/Analysis/test-alias-analysis.mlir --- a/mlir/test/Analysis/test-alias-analysis.mlir +++ b/mlir/test/Analysis/test-alias-analysis.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt %s -pass-pipeline='func(test-alias-analysis)' -split-input-file -allow-unregistered-dialect 2>&1 | FileCheck %s +// RUN: mlir-opt %s -pass-pipeline='builtin.func(test-alias-analysis)' -split-input-file -allow-unregistered-dialect 2>&1 | FileCheck %s // CHECK-LABEL: Testing : "simple" // CHECK-DAG: func.region0#0 <-> func.region0#1: MayAlias diff --git a/mlir/test/CAPI/ir.c b/mlir/test/CAPI/ir.c --- a/mlir/test/CAPI/ir.c +++ b/mlir/test/CAPI/ir.c @@ -97,8 +97,8 @@ mlirNamedAttributeGet( mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("sym_name")), funcNameAttr)}; - MlirOperationState funcState = - mlirOperationStateGet(mlirStringRefCreateFromCString("func"), location); + MlirOperationState funcState = mlirOperationStateGet( + mlirStringRefCreateFromCString("builtin.func"), location); mlirOperationStateAddAttributes(&funcState, 2, funcAttrs); mlirOperationStateAddOwnedRegions(&funcState, 1, &funcBodyRegion); MlirOperation func = mlirOperationCreate(&funcState); diff --git a/mlir/test/CAPI/pass.c b/mlir/test/CAPI/pass.c --- a/mlir/test/CAPI/pass.c +++ b/mlir/test/CAPI/pass.c @@ -41,7 +41,7 @@ // Run the print-op-stats pass on the top-level module: // CHECK-LABEL: Operations encountered: - // CHECK: func , 1 + // CHECK: builtin.func , 1 // CHECK: std.addi , 1 // CHECK: std.return , 1 { @@ -83,13 +83,13 @@ // Run the print-op-stats pass on functions under the top-level module: // CHECK-LABEL: Operations encountered: - // CHECK: func , 1 + // CHECK: builtin.func , 1 // CHECK: std.addi , 1 // CHECK: std.return , 1 { MlirPassManager pm = mlirPassManagerCreate(ctx); MlirOpPassManager nestedFuncPm = mlirPassManagerGetNestedUnder( - pm, mlirStringRefCreateFromCString("func")); + pm, mlirStringRefCreateFromCString("builtin.func")); MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats(); mlirOpPassManagerAddOwnedPass(nestedFuncPm, printOpStatPass); MlirLogicalResult success = mlirPassManagerRun(pm, module); @@ -99,15 +99,15 @@ } // Run the print-op-stats pass on functions under the nested module: // CHECK-LABEL: Operations encountered: - // CHECK: func , 1 + // CHECK: builtin.func , 1 // CHECK: std.addf , 1 // CHECK: std.return , 1 { MlirPassManager pm = mlirPassManagerCreate(ctx); MlirOpPassManager nestedModulePm = mlirPassManagerGetNestedUnder( - pm, mlirStringRefCreateFromCString("module")); + pm, mlirStringRefCreateFromCString("builtin.module")); MlirOpPassManager nestedFuncPm = mlirOpPassManagerGetNestedUnder( - nestedModulePm, mlirStringRefCreateFromCString("func")); + nestedModulePm, mlirStringRefCreateFromCString("builtin.func")); MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats(); mlirOpPassManagerAddOwnedPass(nestedFuncPm, printOpStatPass); MlirLogicalResult success = mlirPassManagerRun(pm, module); @@ -130,21 +130,21 @@ MlirPassManager pm = mlirPassManagerCreate(ctx); // Populate the pass-manager MlirOpPassManager nestedModulePm = mlirPassManagerGetNestedUnder( - pm, mlirStringRefCreateFromCString("module")); + pm, mlirStringRefCreateFromCString("builtin.module")); MlirOpPassManager nestedFuncPm = mlirOpPassManagerGetNestedUnder( - nestedModulePm, mlirStringRefCreateFromCString("func")); + nestedModulePm, mlirStringRefCreateFromCString("builtin.func")); MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats(); mlirOpPassManagerAddOwnedPass(nestedFuncPm, printOpStatPass); // Print the top level pass manager - // CHECK: Top-level: module(func(print-op-stats)) + // CHECK: Top-level: builtin.module(builtin.func(print-op-stats)) fprintf(stderr, "Top-level: "); mlirPrintPassPipeline(mlirPassManagerGetAsOpPassManager(pm), printToStderr, NULL); fprintf(stderr, "\n"); // Print the pipeline nested one level down - // CHECK: Nested Module: func(print-op-stats) + // CHECK: Nested Module: builtin.func(print-op-stats) fprintf(stderr, "Nested Module: "); mlirPrintPassPipeline(nestedModulePm, printToStderr, NULL); fprintf(stderr, "\n"); @@ -166,7 +166,7 @@ MlirLogicalResult status = mlirParsePassPipeline( mlirPassManagerGetAsOpPassManager(pm), mlirStringRefCreateFromCString( - "module(func(print-op-stats), func(print-op-stats))")); + "builtin.module(builtin.func(print-op-stats), builtin.func(print-op-stats))")); // Expect a failure, we haven't registered the print-op-stats pass yet. if (mlirLogicalResultIsSuccess(status)) { fprintf(stderr, "Unexpected success parsing pipeline without registering the pass\n"); @@ -177,14 +177,14 @@ status = mlirParsePassPipeline( mlirPassManagerGetAsOpPassManager(pm), mlirStringRefCreateFromCString( - "module(func(print-op-stats), func(print-op-stats))")); + "builtin.module(builtin.func(print-op-stats), builtin.func(print-op-stats))")); // Expect a failure, we haven't registered the print-op-stats pass yet. if (mlirLogicalResultIsFailure(status)) { fprintf(stderr, "Unexpected failure parsing pipeline after registering the pass\n"); exit(EXIT_FAILURE); } - // CHECK: Round-trip: module(func(print-op-stats), func(print-op-stats)) + // CHECK: Round-trip: builtin.module(builtin.func(print-op-stats), builtin.func(print-op-stats)) fprintf(stderr, "Round-trip: "); mlirPrintPassPipeline(mlirPassManagerGetAsOpPassManager(pm), printToStderr, NULL); 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:.*]] = unrealized_conversion_cast %[[C]] : index to i64 + // CHECK: %[[S:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[CPLX]] : complex to !llvm.struct<(f32, f32)> +// CHECK-NEXT: %[[CAST0:.*]] = builtin.unrealized_conversion_cast %[[CPLX]] : complex to !llvm.struct<(f32, f32)> // CHECK-NEXT: %[[REAL:.*]] = llvm.extractvalue %[[CAST0]][0] : !llvm.struct<(f32, f32)> -// CHECK-NEXT: %[[CAST1:.*]] = unrealized_conversion_cast %[[CPLX]] : complex to !llvm.struct<(f32, f32)> +// CHECK-NEXT: %[[CAST1:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[LHS]] : complex to ![[C_TY:.*>]] -// CHECK: %[[CASTED_RHS:.*]] = unrealized_conversion_cast %[[RHS]] : complex to ![[C_TY]] +// 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: %[[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:.*]] = unrealized_conversion_cast %[[RESULT_2]] : ![[C_TY]] to complex +// CHECK: %[[CASTED_RESULT:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[LHS]] : complex to ![[C_TY:.*>]] -// CHECK: %[[CASTED_RHS:.*]] = unrealized_conversion_cast %[[RHS]] : complex to ![[C_TY]] +// 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: %[[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:.*]] = unrealized_conversion_cast %[[RESULT_2]] : ![[C_TY]] to complex +// CHECK: %[[CASTED_RESULT:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[ARG]] : complex to ![[C_TY:.*>]] +// CHECK: %[[CASTED_ARG:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[Marg]] -// CHECK: %[[N:.*]] = unrealized_conversion_cast %[[Narg]] +// CHECK: %[[M:.*]] = builtin.unrealized_conversion_cast %[[Marg]] +// CHECK: %[[N:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[Marg]] -// CHECK: %[[N:.*]] = unrealized_conversion_cast %[[Narg]] +// CHECK: %[[M:.*]] = builtin.unrealized_conversion_cast %[[Marg]] +// CHECK: %[[N:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[Marg]] -// CHECK: %[[N:.*]] = unrealized_conversion_cast %[[Narg]] +// CHECK: %[[M:.*]] = builtin.unrealized_conversion_cast %[[Marg]] +// CHECK: %[[N:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[Iarg]] -// CHECK: %[[J:.*]] = unrealized_conversion_cast %[[Jarg]] +// CHECK: %[[I:.*]] = builtin.unrealized_conversion_cast %[[Iarg]] +// CHECK: %[[J:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[Iarg]] -// CHECK: %[[J:.*]] = unrealized_conversion_cast %[[Jarg]] +// CHECK: %[[I:.*]] = builtin.unrealized_conversion_cast %[[Iarg]] +// CHECK: %[[J:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[Iarg]] -// CHECK: %[[J:.*]] = unrealized_conversion_cast %[[Jarg]] +// CHECK: %[[I:.*]] = builtin.unrealized_conversion_cast %[[Iarg]] +// CHECK: %[[J:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[Iarg]] -// CHECK: %[[J:.*]] = unrealized_conversion_cast %[[Jarg]] +// CHECK: %[[I:.*]] = builtin.unrealized_conversion_cast %[[Iarg]] +// CHECK: %[[J:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[Iarg]] -// CHECK: %[[J:.*]] = unrealized_conversion_cast %[[Jarg]] +// CHECK: %[[I:.*]] = builtin.unrealized_conversion_cast %[[Iarg]] +// CHECK: %[[J:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[IDXarg]] + // CHECK-DAG: %[[IDX:.*]] = builtin.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:%.*]] = unrealized_conversion_cast %{{.*}} : +// CHECK: [[INPUT:%.*]] = builtin.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:%.*]] = 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: [[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: [[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:%.*]] = unrealized_conversion_cast %{{.*}} to [[INPUT_TY:!.*]] -// CHECK: [[SHAPE:%.*]] = unrealized_conversion_cast %{{.*}} to [[SHAPE_TY:!.*]] +// CHECK: [[INPUT:%.*]] = builtin.unrealized_conversion_cast %{{.*}} to [[INPUT_TY:!.*]] +// CHECK: [[SHAPE:%.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[I]] -// CHECK: %[[JJ:.*]] = unrealized_conversion_cast %[[J]] +// CHECK: %[[II:.*]] = builtin.unrealized_conversion_cast %[[I]] +// CHECK: %[[JJ:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[I]] -// CHECK: %[[JJ:.*]] = unrealized_conversion_cast %[[J]] +// CHECK: %[[II:.*]] = builtin.unrealized_conversion_cast %[[I]] +// CHECK: %[[JJ:.*]] = builtin.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:.*]] = unrealized_conversion_cast + // CHECK: %[[CST:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[ARG2F:.*]] - // CHECK: %[[ARG0:.*]] = unrealized_conversion_cast %[[ARG0F:.*]] - // CHECK: %[[ARG1:.*]] = unrealized_conversion_cast %[[ARG1F:.*]] + // CHECK: %[[ARG2:.*]] = builtin.unrealized_conversion_cast %[[ARG2F:.*]] + // CHECK: %[[ARG0:.*]] = builtin.unrealized_conversion_cast %[[ARG0F:.*]] + // CHECK: %[[ARG1:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[ARG2F:.*]] - // CHECK: %[[ARG1:.*]] = unrealized_conversion_cast %[[ARG1F:.*]] + // CHECK: %[[ARG2:.*]] = builtin.unrealized_conversion_cast %[[ARG2F:.*]] + // CHECK: %[[ARG1:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[ARG2F:.*]] + // CHECK: %[[ARG2:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[ARG2F:.*]] + // CHECK: %[[ARG2:.*]] = builtin.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:.*]] = 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: %[[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: %[[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:.*]] = 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: %[[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: %[[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:.*]] = 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: %[[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: %[[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:.*]] = 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: %[[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: %[[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:.*]] = unrealized_conversion_cast - // CHECK32: %[[MEMREF:.*]] = unrealized_conversion_cast + // CHECK: %[[MEMREF:.*]] = builtin.unrealized_conversion_cast + // CHECK32: %[[MEMREF:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[MEM]] - // CHECK32: %[[ARG1:.*]] = unrealized_conversion_cast %[[ARG1f]] - // CHECK32: %[[ARG2:.*]] = unrealized_conversion_cast %[[ARG2f]] - // CHECK32: %[[ARG0:.*]] = unrealized_conversion_cast %[[ARG0f]] + // 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: %[[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:.*]] = unrealized_conversion_cast +// CHECK: %[[UNRANKED_DESC:.*]] = builtin.unrealized_conversion_cast // CHECK: %[[RANKED_DESC:.*]] = llvm.extractvalue %[[UNRANKED_DESC]][1] // CHECK-SAME: : !llvm.struct<(i64, ptr)> 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:.*]] = unrealized_conversion_cast %[[input]] : vector<16xindex> to vector<16xi64> +// CHECK: %[[T0:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T0]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> +// CHECK: %[[T1:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T4]] : !llvm.array<3 x vector<2xf32>> to vector<3x2xf32> +// CHECK: %[[T5:.*]] = builtin.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:.*]] = 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: %[[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: %[[T3:.*]] = llvm.insertvalue %[[T1]], %[[T2]][0] : !llvm.array<3 x vector<2xi64>> -// CHECK: %[[T4:.*]] = unrealized_conversion_cast %{{.*}} : !llvm.array<3 x vector<2xi64>> to vector<3x2xindex> +// CHECK: %[[T4:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T0]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> +// CHECK: %[[T2:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T1]] : vector<4x3x2xf32> to !llvm.array<4 x 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: %[[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:.*]] = unrealized_conversion_cast %[[T10]] : !llvm.array<4 x array<3 x vector<2xf32>>> to vector<4x3x2xf32> +// CHECK: %[[T11:.*]] = builtin.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:.*]] = 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: %[[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: %[[T3:.*]] = llvm.insertvalue %[[T1]], %[[T2]][0] : !llvm.array<4 x array<3 x vector<2xf32>>> -// CHECK: %[[T4:.*]] = unrealized_conversion_cast %[[A]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> +// CHECK: %[[T4:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> +// CHECK: %[[T6:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> +// CHECK: %[[T8:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T9]] : !llvm.array<4 x array<3 x vector<2xf32>>> to vector<4x3x2xf32> +// CHECK: %[[T10:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : vector<1x4xf32> to !llvm.array<1 x vector<4xf32>> +// CHECK: %[[T2:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T1]] : vector<3x4xf32> to !llvm.array<3 x vector<4xf32>> +// CHECK: %[[T4:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T7]] : !llvm.array<3 x vector<4xf32>> to vector<3x4xf32> +// CHECK: %[[T8:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : vector<4x1xf32> to !llvm.array<4 x vector<1xf32>> +// CHECK: %[[T2:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T1]] : vector<4x3xf32> to !llvm.array<4 x vector<3xf32>> +// CHECK: %[[T7:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : vector<4x1xf32> to !llvm.array<4 x vector<1xf32>> +// CHECK: %[[T9:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : vector<4x1xf32> to !llvm.array<4 x vector<1xf32>> +// CHECK: %[[T15:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : vector<4x1xf32> to !llvm.array<4 x vector<1xf32>> +// CHECK: %[[T21:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T26]] : !llvm.array<4 x vector<3xf32>> to vector<4x3xf32> +// CHECK: %[[T27:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : vector<4x1x2xf32> to !llvm.array<4 x array<1 x vector<2xf32>>> +// CHECK: %[[T3:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T2]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> +// CHECK: %[[T5:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T1]] : vector<4x3x2xf32> to !llvm.array<4 x 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: %[[T10:.*]] = llvm.insertvalue %[[T8]], %[[T9]][0] : !llvm.array<4 x array<3 x vector<2xf32>>> -// CHECK: %[[T11:.*]] = unrealized_conversion_cast %[[A]] : vector<4x1x2xf32> to !llvm.array<4 x array<1 x vector<2xf32>>> +// CHECK: %[[T11:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T2]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> +// CHECK: %[[T13:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : vector<4x1x2xf32> to !llvm.array<4 x array<1 x vector<2xf32>>> +// CHECK: %[[T18:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T2]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> +// CHECK: %[[T20:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : vector<4x1x2xf32> to !llvm.array<4 x array<1 x vector<2xf32>>> +// CHECK: %[[T25:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T2]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> +// CHECK: %[[T27:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T31]] : !llvm.array<4 x array<3 x vector<2xf32>>> to vector<4x3x2xf32> +// CHECK: %[[T32:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T2]] : vector<2x3xf32> to !llvm.array<2 x vector<3xf32>> +// CHECK: %[[T7:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T13]] : !llvm.array<2 x vector<3xf32>> to vector<2x3xf32> +// CHECK: %[[T14:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : vector<2xindex> to vector<2xi64> +// CHECK: %[[T1:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T3]] : i64 to index +// CHECK: %[[T4:.*]] = builtin.unrealized_conversion_cast %[[T3]] : i64 to index // CHECK: %[[T5:.*]] = splat %[[T4]] : vector<3xindex> // CHECK: %[[T6:.*]] = muli %[[T5]], %[[B]] : vector<3xindex> -// 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: %[[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: %{{.*}} = 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:.*]] = unrealized_conversion_cast %[[C]] : vector<2x3xf32> to !llvm.array<2 x vector<3xf32>> +// CHECK: %[[T7:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T3]] : vector<2x3xf32> to !llvm.array<2 x vector<3xf32>> +// CHECK: %[[T10:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[C]] : vector<2x3xf32> to !llvm.array<2 x vector<3xf32>> +// CHECK: %[[T15:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T18]] : !llvm.array<2 x vector<3xf32>> to vector<2x3xf32> +// CHECK: %[[T19:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : vector<2xindex> to vector<2xi64> -// CHECK: %[[T1:.*]] = unrealized_conversion_cast %[[B]] : vector<2xindex> to vector<2xi64> +// 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: %[[T2:.*]] = llvm.shufflevector %[[T0]], %[[T1]] [0, 1] : vector<2xi64>, vector<2xi64> -// CHECK: %[[T3:.*]] = unrealized_conversion_cast %[[T2]] : vector<2xi64> to vector<2xindex> +// CHECK: %[[T3:.*]] = builtin.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:.*]] = 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: %[[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: %[[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:.*]] = unrealized_conversion_cast %[[i3]] : !llvm.array<3 x vector<4xf32>> to vector<3x4xf32> +// CHECK: %[[VAL_3:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : vector<16xindex> to vector<16xi64> +// CHECK: %[[T0:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T2]] : i64 to index +// CHECK: %[[T3:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : index to i64 -// CHECK: %[[T1:.*]] = unrealized_conversion_cast %[[B]] : vector<4xindex> to vector<4xi64> +// CHECK: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : index to i64 +// CHECK: %[[T1:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T4]] : vector<4xi64> to vector<4xindex> +// CHECK: %[[T5:.*]] = builtin.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: %{{.*}} = 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 %[[A]] : memref<8x8x8xindex> to !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> -// CHECK: %{{.*}} = unrealized_conversion_cast %{{.*}} : !llvm.struct<(ptr>>>, ptr>>>, i64)> to memref> +// CHECK: %{{.*}} = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : si4 to i4 +// CHECK: %[[C:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : ui4 to i4 +// CHECK: %[[C:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : ui32 to i32 +// CHECK: %[[C:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : si40 to i40 +// CHECK: %[[C:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : ui40 to i40 +// CHECK: %[[C:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : ui64 to i64 +// CHECK: %[[C:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : index to i64 +// CHECK: %[[C:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : vector<2x2xf32> to !llvm.array<2 x vector<2xf32>> +// CHECK: %[[VAL_1:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : vector<4xindex> to vector<4xi64> -// CHECK: %[[T1:.*]] = unrealized_conversion_cast %[[A]] : vector<4xindex> to vector<4xi64> +// 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: %[[T2:.*]] = llvm.shufflevector %[[T0]], %[[T1]] [2, 3] : vector<4xi64>, vector<4xi64> -// CHECK: %[[T3:.*]] = unrealized_conversion_cast %[[T2]] : vector<2xi64> to vector<2xindex> +// CHECK: %[[T3:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[ARG]] : vector<4x8xf32> to !llvm.array<4 x vector<8xf32>> +// CHECK: %[[A:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T4]] : !llvm.array<2 x vector<8xf32>> to vector<2x8xf32> +// CHECK: %[[T5:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[ARG]] : vector<4x8xf32> to !llvm.array<4 x vector<8xf32>> +// CHECK: %[[A:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[VAL_2]] : vector<2x2xf32> to !llvm.array<2 x vector<2xf32>> +// CHECK: %[[VAL_6:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[ARG]] : vector<4x8xf32> to !llvm.array<4 x vector<8xf32>> +// CHECK: %[[A:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T7]] : !llvm.array<2 x vector<2xf32>> to vector<2x2xf32> +// CHECK: %[[VAL_12:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[B]] : vector<16x4x8xf32> to !llvm.array<16 x array<4 x vector<8xf32>>> +// CHECK: %[[s2:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> +// CHECK: %[[s4:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[B]] : vector<16x4x8xf32> to !llvm.array<16 x array<4 x vector<8xf32>>> +// CHECK: %[[s6:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[s8]] : index to i64 +// CHECK: %[[s9:.*]] = builtin.unrealized_conversion_cast %[[s8]] : index to i64 // CHECK: %[[s10:.*]] = llvm.extractelement %[[s5]]{{\[}}%[[s9]] : i64] : vector<4xf32> // CHECK: %[[s11:.*]] = constant 2 : index -// CHECK: %[[s12:.*]] = unrealized_conversion_cast %[[s11]] : index to i64 +// CHECK: %[[s12:.*]] = builtin.unrealized_conversion_cast %[[s11]] : index to i64 // CHECK: %[[s13:.*]] = llvm.insertelement %[[s10]], %[[s7]]{{\[}}%[[s12]] : i64] : vector<8xf32> // CHECK: %[[s14:.*]] = constant 1 : index -// CHECK: %[[s15:.*]] = unrealized_conversion_cast %[[s14]] : index to i64 +// CHECK: %[[s15:.*]] = builtin.unrealized_conversion_cast %[[s14]] : index to i64 // CHECK: %[[s16:.*]] = llvm.extractelement %[[s5]]{{\[}}%[[s15]] : i64] : vector<4xf32> // CHECK: %[[s17:.*]] = constant 3 : index -// CHECK: %[[s18:.*]] = unrealized_conversion_cast %[[s17]] : index to i64 +// CHECK: %[[s18:.*]] = builtin.unrealized_conversion_cast %[[s17]] : index to i64 // CHECK: %[[s19:.*]] = llvm.insertelement %[[s16]], %[[s13]]{{\[}}%[[s18]] : i64] : vector<8xf32> // CHECK: %[[s20:.*]] = constant 2 : index -// CHECK: %[[s21:.*]] = unrealized_conversion_cast %[[s20]] : index to i64 +// CHECK: %[[s21:.*]] = builtin.unrealized_conversion_cast %[[s20]] : index to i64 // CHECK: %[[s22:.*]] = llvm.extractelement %[[s5]]{{\[}}%[[s21]] : i64] : vector<4xf32> // CHECK: %[[s23:.*]] = constant 4 : index -// CHECK: %[[s24:.*]] = unrealized_conversion_cast %[[s23]] : index to i64 +// CHECK: %[[s24:.*]] = builtin.unrealized_conversion_cast %[[s23]] : index to i64 // CHECK: %[[s25:.*]] = llvm.insertelement %[[s22]], %[[s19]]{{\[}}%[[s24]] : i64] : vector<8xf32> // CHECK: %[[s26:.*]] = constant 3 : index -// CHECK: %[[s27:.*]] = unrealized_conversion_cast %[[s26]] : index to i64 +// CHECK: %[[s27:.*]] = builtin.unrealized_conversion_cast %[[s26]] : index to i64 // CHECK: %[[s28:.*]] = llvm.extractelement %[[s5]]{{\[}}%[[s27]] : i64] : vector<4xf32> // CHECK: %[[s29:.*]] = constant 5 : index -// CHECK: %[[s30:.*]] = unrealized_conversion_cast %[[s29]] : index to i64 +// CHECK: %[[s30:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> +// CHECK: %[[s33:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[B]] : vector<16x4x8xf32> to !llvm.array<16 x array<4 x vector<8xf32>>> +// CHECK: %[[s35:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[s37]] : index to i64 +// CHECK: %[[s38:.*]] = builtin.unrealized_conversion_cast %[[s37]] : index to i64 // CHECK: %[[s39:.*]] = llvm.extractelement %[[s34]]{{\[}}%[[s38]] : i64] : vector<4xf32> // CHECK: %[[s40:.*]] = constant 2 : index -// CHECK: %[[s41:.*]] = unrealized_conversion_cast %[[s40]] : index to i64 +// CHECK: %[[s41:.*]] = builtin.unrealized_conversion_cast %[[s40]] : index to i64 // CHECK: %[[s42:.*]] = llvm.insertelement %[[s39]], %[[s36]]{{\[}}%[[s41]] : i64] : vector<8xf32> // CHECK: %[[s43:.*]] = constant 1 : index -// CHECK: %[[s44:.*]] = unrealized_conversion_cast %[[s43]] : index to i64 +// CHECK: %[[s44:.*]] = builtin.unrealized_conversion_cast %[[s43]] : index to i64 // CHECK: %[[s45:.*]] = llvm.extractelement %[[s34]]{{\[}}%[[s44]] : i64] : vector<4xf32> // CHECK: %[[s46:.*]] = constant 3 : index -// CHECK: %[[s47:.*]] = unrealized_conversion_cast %[[s46]] : index to i64 +// CHECK: %[[s47:.*]] = builtin.unrealized_conversion_cast %[[s46]] : index to i64 // CHECK: %[[s48:.*]] = llvm.insertelement %[[s45]], %[[s42]]{{\[}}%[[s47]] : i64] : vector<8xf32> // CHECK: %[[s49:.*]] = constant 2 : index -// CHECK: %[[s50:.*]] = unrealized_conversion_cast %[[s49]] : index to i64 +// CHECK: %[[s50:.*]] = builtin.unrealized_conversion_cast %[[s49]] : index to i64 // CHECK: %[[s51:.*]] = llvm.extractelement %[[s34]]{{\[}}%[[s50]] : i64] : vector<4xf32> // CHECK: %[[s52:.*]] = constant 4 : index -// CHECK: %[[s53:.*]] = unrealized_conversion_cast %[[s52]] : index to i64 +// CHECK: %[[s53:.*]] = builtin.unrealized_conversion_cast %[[s52]] : index to i64 // CHECK: %[[s54:.*]] = llvm.insertelement %[[s51]], %[[s48]]{{\[}}%[[s53]] : i64] : vector<8xf32> // CHECK: %[[s55:.*]] = constant 3 : index -// CHECK: %[[s56:.*]] = unrealized_conversion_cast %[[s55]] : index to i64 +// CHECK: %[[s56:.*]] = builtin.unrealized_conversion_cast %[[s55]] : index to i64 // CHECK: %[[s57:.*]] = llvm.extractelement %[[s34]]{{\[}}%[[s56]] : i64] : vector<4xf32> // CHECK: %[[s58:.*]] = constant 5 : index -// CHECK: %[[s59:.*]] = unrealized_conversion_cast %[[s58]] : index to i64 +// CHECK: %[[s59:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[B]] : vector<16x4x8xf32> to !llvm.array<16 x 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: %[[s63:.*]] = llvm.insertvalue %[[s61]], %[[s62]][0] : !llvm.array<16 x array<4 x vector<8xf32>>> -// CHECK: %[[s64:.*]] = unrealized_conversion_cast %[[s63]] : !llvm.array<16 x array<4 x vector<8xf32>>> to vector<16x4x8xf32> +// CHECK: %[[s64:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> + // CHECK: %[[BL:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> + // CHECK: %[[BL:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> + // CHECK: %[[BL:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> + // CHECK: %[[BL:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> + // CHECK: %[[BL:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> + // CHECK: %[[BL:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : vector<16xindex> to vector<16xi64> +// CHECK: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<16xindex> to vector<16xi64> // CHECK: %[[T1:.*]] = "llvm.intr.vector.reduce.add"(%[[T0]]) -// CHECK: %[[T2:.*]] = unrealized_conversion_cast %[[T1]] : i64 to index +// CHECK: %[[T2:.*]] = builtin.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: %{{.*}} = unrealized_conversion_cast %[[SPLAT]] : vector<17xindex> to vector<17xi64> +// CHECK: %{{.*}} = builtin.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:.*]] = unrealized_conversion_cast %[[VAL_1]] : vector<4x4xi1> to !llvm.array<4 x vector<4xi1>> +// CHECK: %[[VAL_2:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[VAL_4]] : !llvm.array<4 x vector<4xi1>> to vector<4x4xi1> +// CHECK: %[[VAL_5:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[A]] : vector<16xindex> to vector<16xi64> +// CHECK: %[[T0:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T1]] : vector<16xi64> to vector<16xindex> +// CHECK: %[[T2:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[T0]] : vector<8xi64> to vector<8xindex> +// CHECK: %[[T1:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[CO]] : index to i64 +// CHECK: %[[C:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[CO]] : index to i64 +// CHECK: %[[C:.*]] = builtin.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: %{{.*}} = unrealized_conversion_cast %[[G]] : vector<3xi64> to vector<3xindex> +// CHECK: %{{.*}} = builtin.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:.*]] = unrealized_conversion_cast %[[CO]] : index to i64 +// CHECK: %[[C:.*]] = builtin.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:.*]] = unrealized_conversion_cast %[[CO]] : index to i64 +// CHECK: %[[C:.*]] = builtin.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/Affine/canonicalize.mlir b/mlir/test/Dialect/Affine/canonicalize.mlir --- a/mlir/test/Dialect/Affine/canonicalize.mlir +++ b/mlir/test/Dialect/Affine/canonicalize.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -pass-pipeline='func(canonicalize)' | FileCheck %s +// RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -pass-pipeline='builtin.func(canonicalize)' | FileCheck %s // ----- 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 @@ -1,4 +1,4 @@ -// RUN: mlir-opt %s -convert-vector-to-llvm="enable-arm-sve" | mlir-opt | FileCheck %s +// RUN: mlir-opt %s -convert-vector-to-llvm="enable-arm-sve" | mlir-opt | FileCheck %s // CHECK: memcopy([[SRC:%arg[0-9]+]]: memref, [[DST:%arg[0-9]+]] func @memcopy(%src : memref, %dst : memref, %size : index) { @@ -7,17 +7,17 @@ %vs = arm_sve.vector_scale : index %step = muli %c4, %vs : index - // CHECK: scf.for [[LOOPIDX:%arg[0-9]+]] = {{.*}} + // CHECK: scf.for [[LOOPIDX:%arg[0-9]+]] = {{.*}} scf.for %i0 = %c0 to %size step %step { - // 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: [[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: [[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]+]] = unrealized_conversion_cast [[DST]] : memref to !llvm.struct<(ptr - // CHECK: [[DSTIDX:%[0-9]+]] = unrealized_conversion_cast [[LOOPIDX]] : index to i64 + // 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: [[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/Builtin/invalid.mlir b/mlir/test/Dialect/Builtin/invalid.mlir --- a/mlir/test/Dialect/Builtin/invalid.mlir +++ b/mlir/test/Dialect/Builtin/invalid.mlir @@ -5,7 +5,7 @@ //===----------------------------------------------------------------------===// // expected-error@+1 {{expected at least one result for cast operation}} -"unrealized_conversion_cast"() : () -> () +"builtin.unrealized_conversion_cast"() : () -> () // ----- diff --git a/mlir/test/Dialect/LLVMIR/terminator.mlir b/mlir/test/Dialect/LLVMIR/terminator.mlir --- a/mlir/test/Dialect/LLVMIR/terminator.mlir +++ b/mlir/test/Dialect/LLVMIR/terminator.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt -pass-pipeline='func(canonicalize)' %s | FileCheck %s +// RUN: mlir-opt -pass-pipeline='builtin.func(canonicalize)' %s | FileCheck %s // verify that terminators survive the canonicalizer // CHECK-LABEL: @return diff --git a/mlir/test/Dialect/Linalg/fusion-sequence.mlir b/mlir/test/Dialect/Linalg/fusion-sequence.mlir --- a/mlir/test/Dialect/Linalg/fusion-sequence.mlir +++ b/mlir/test/Dialect/Linalg/fusion-sequence.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt -pass-pipeline="func(test-linalg-tile-and-fuse{tile-sizes=16,32,64}),resolve-shaped-type-result-dims,canonicalize,cse" -split-input-file %s | FileCheck %s +// RUN: mlir-opt -pass-pipeline="builtin.func(test-linalg-tile-and-fuse{tile-sizes=16,32,64}),resolve-shaped-type-result-dims,canonicalize,cse" -split-input-file %s | FileCheck %s module { func @three_op_fusion(%arg0: memref, %arg1: memref, diff --git a/mlir/test/Dialect/Quant/canonicalize.mlir b/mlir/test/Dialect/Quant/canonicalize.mlir --- a/mlir/test/Dialect/Quant/canonicalize.mlir +++ b/mlir/test/Dialect/Quant/canonicalize.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt %s -split-input-file -pass-pipeline='func(canonicalize)' | FileCheck %s +// RUN: mlir-opt %s -split-input-file -pass-pipeline='builtin.func(canonicalize)' | FileCheck %s // ----- // CHECK-LABEL: redundant_scast diff --git a/mlir/test/Dialect/SCF/canonicalize.mlir b/mlir/test/Dialect/SCF/canonicalize.mlir --- a/mlir/test/Dialect/SCF/canonicalize.mlir +++ b/mlir/test/Dialect/SCF/canonicalize.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt %s -pass-pipeline='func(canonicalize)' -split-input-file | FileCheck %s +// RUN: mlir-opt %s -pass-pipeline='builtin.func(canonicalize)' -split-input-file | FileCheck %s // ----- diff --git a/mlir/test/Dialect/SCF/loop-range.mlir b/mlir/test/Dialect/SCF/loop-range.mlir --- a/mlir/test/Dialect/SCF/loop-range.mlir +++ b/mlir/test/Dialect/SCF/loop-range.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt %s -pass-pipeline='func(for-loop-range-folding)' -split-input-file | FileCheck %s +// RUN: mlir-opt %s -pass-pipeline='builtin.func(for-loop-range-folding)' -split-input-file | FileCheck %s func @fold_one_loop(%arg0: memref, %arg1: index, %arg2: index) { %c0 = constant 0 : index diff --git a/mlir/test/Dialect/SCF/parallel-loop-fusion.mlir b/mlir/test/Dialect/SCF/parallel-loop-fusion.mlir --- a/mlir/test/Dialect/SCF/parallel-loop-fusion.mlir +++ b/mlir/test/Dialect/SCF/parallel-loop-fusion.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func(parallel-loop-fusion)' -split-input-file | FileCheck %s +// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='builtin.func(parallel-loop-fusion)' -split-input-file | FileCheck %s func @fuse_empty_loops() { %c2 = constant 2 : index diff --git a/mlir/test/Dialect/SCF/parallel-loop-tiling.mlir b/mlir/test/Dialect/SCF/parallel-loop-tiling.mlir --- a/mlir/test/Dialect/SCF/parallel-loop-tiling.mlir +++ b/mlir/test/Dialect/SCF/parallel-loop-tiling.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt %s -pass-pipeline='func(parallel-loop-tiling{parallel-loop-tile-sizes=1,4})' -split-input-file | FileCheck %s +// RUN: mlir-opt %s -pass-pipeline='builtin.func(parallel-loop-tiling{parallel-loop-tile-sizes=1,4})' -split-input-file | FileCheck %s func @parallel_loop(%arg0 : index, %arg1 : index, %arg2 : index, %arg3 : index, %arg4 : index, %arg5 : index, diff --git a/mlir/test/Dialect/SPIRV/Transforms/canonicalize.mlir b/mlir/test/Dialect/SPIRV/Transforms/canonicalize.mlir --- a/mlir/test/Dialect/SPIRV/Transforms/canonicalize.mlir +++ b/mlir/test/Dialect/SPIRV/Transforms/canonicalize.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt %s -split-input-file -pass-pipeline='func(canonicalize)' | FileCheck %s +// RUN: mlir-opt %s -split-input-file -pass-pipeline='builtin.func(canonicalize)' | FileCheck %s //===----------------------------------------------------------------------===// // spv.AccessChain diff --git a/mlir/test/Dialect/Standard/canonicalize-cf.mlir b/mlir/test/Dialect/Standard/canonicalize-cf.mlir --- a/mlir/test/Dialect/Standard/canonicalize-cf.mlir +++ b/mlir/test/Dialect/Standard/canonicalize-cf.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt %s -allow-unregistered-dialect -pass-pipeline='func(canonicalize)' -split-input-file | FileCheck --dump-input-context 20 %s +// RUN: mlir-opt %s -allow-unregistered-dialect -pass-pipeline='builtin.func(canonicalize)' -split-input-file | FileCheck --dump-input-context 20 %s /// Test the folding of BranchOp. diff --git a/mlir/test/Dialect/Vector/canonicalize.mlir b/mlir/test/Dialect/Vector/canonicalize.mlir --- a/mlir/test/Dialect/Vector/canonicalize.mlir +++ b/mlir/test/Dialect/Vector/canonicalize.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt %s -pass-pipeline='func(canonicalize)' -split-input-file -allow-unregistered-dialect | FileCheck %s +// RUN: mlir-opt %s -pass-pipeline='builtin.func(canonicalize)' -split-input-file -allow-unregistered-dialect | FileCheck %s // ----- 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 @@ -815,7 +815,7 @@ func @return_not_in_function() { "foo.region"() ({ - // expected-error@+1 {{'std.return' op expects parent op 'func'}} + // expected-error@+1 {{'std.return' op expects parent op 'builtin.func'}} return }): () -> () return diff --git a/mlir/test/IR/print-ir-defuse.mlir b/mlir/test/IR/print-ir-defuse.mlir --- a/mlir/test/IR/print-ir-defuse.mlir +++ b/mlir/test/IR/print-ir-defuse.mlir @@ -18,7 +18,7 @@ // CHECK: Has 0 results: // CHECK: Visiting op 'dialect.op3' with 0 operands: // CHECK: Has 0 results: -// CHECK: Visiting op 'module' with 0 operands: +// CHECK: Visiting op 'builtin.module' with 0 operands: // CHECK: Has 0 results: %results:4 = "dialect.op1"() : () -> (i1, i16, i32, i64) diff --git a/mlir/test/IR/print-ir-nesting.mlir b/mlir/test/IR/print-ir-nesting.mlir --- a/mlir/test/IR/print-ir-nesting.mlir +++ b/mlir/test/IR/print-ir-nesting.mlir @@ -1,6 +1,6 @@ // RUN: mlir-opt -test-print-nesting -allow-unregistered-dialect %s | FileCheck %s -// CHECK: visiting op: 'module' with 0 operands and 0 results +// CHECK: visiting op: 'builtin.module' with 0 operands and 0 results // CHECK: 1 nested regions: // CHECK: Region with 1 blocks: // CHECK: Block with 0 arguments, 0 successors, and 2 operations diff --git a/mlir/test/IR/print-op-on-diagnostic.mlir b/mlir/test/IR/print-op-on-diagnostic.mlir --- a/mlir/test/IR/print-op-on-diagnostic.mlir +++ b/mlir/test/IR/print-op-on-diagnostic.mlir @@ -3,5 +3,5 @@ // This file tests the functionality of 'mlir-print-op-on-diagnostic'. // CHECK: {{invalid to use 'test.invalid_attr'}} -// CHECK: {{see current operation: "module"()}} +// CHECK: {{see current operation: "builtin.module"()}} module attributes {test.invalid_attr} {} diff --git a/mlir/test/IR/visitors.mlir b/mlir/test/IR/visitors.mlir --- a/mlir/test/IR/visitors.mlir +++ b/mlir/test/IR/visitors.mlir @@ -22,8 +22,8 @@ } // CHECK-LABEL: Op pre-order visit -// CHECK: Visiting op 'module' -// CHECK: Visiting op 'func' +// CHECK: Visiting op 'builtin.module' +// CHECK: Visiting op 'builtin.func' // CHECK: Visiting op 'scf.for' // CHECK: Visiting op 'use0' // CHECK: Visiting op 'scf.if' @@ -33,15 +33,15 @@ // CHECK: Visiting op 'std.return' // CHECK-LABEL: Block pre-order visits -// CHECK: Visiting block ^bb0 from region 0 from operation 'module' -// CHECK: Visiting block ^bb0 from region 0 from operation 'func' +// CHECK: Visiting block ^bb0 from region 0 from operation 'builtin.module' +// CHECK: Visiting block ^bb0 from region 0 from operation 'builtin.func' // CHECK: Visiting block ^bb0 from region 0 from operation 'scf.for' // CHECK: Visiting block ^bb0 from region 0 from operation 'scf.if' // CHECK: Visiting block ^bb0 from region 1 from operation 'scf.if' // CHECK-LABEL: Region pre-order visits -// CHECK: Visiting region 0 from operation 'module' -// CHECK: Visiting region 0 from operation 'func' +// CHECK: Visiting region 0 from operation 'builtin.module' +// CHECK: Visiting region 0 from operation 'builtin.func' // CHECK: Visiting region 0 from operation 'scf.for' // CHECK: Visiting region 0 from operation 'scf.if' // CHECK: Visiting region 1 from operation 'scf.if' @@ -54,22 +54,22 @@ // CHECK: Visiting op 'use3' // CHECK: Visiting op 'scf.for' // CHECK: Visiting op 'std.return' -// CHECK: Visiting op 'func' -// CHECK: Visiting op 'module' +// CHECK: Visiting op 'builtin.func' +// CHECK: Visiting op 'builtin.module' // CHECK-LABEL: Block post-order visits // CHECK: Visiting block ^bb0 from region 0 from operation 'scf.if' // CHECK: Visiting block ^bb0 from region 1 from operation 'scf.if' // CHECK: Visiting block ^bb0 from region 0 from operation 'scf.for' -// CHECK: Visiting block ^bb0 from region 0 from operation 'func' -// CHECK: Visiting block ^bb0 from region 0 from operation 'module' +// CHECK: Visiting block ^bb0 from region 0 from operation 'builtin.func' +// CHECK: Visiting block ^bb0 from region 0 from operation 'builtin.module' // CHECK-LABEL: Region post-order visits // CHECK: Visiting region 0 from operation 'scf.if' // CHECK: Visiting region 1 from operation 'scf.if' // CHECK: Visiting region 0 from operation 'scf.for' -// CHECK: Visiting region 0 from operation 'func' -// CHECK: Visiting region 0 from operation 'module' +// CHECK: Visiting region 0 from operation 'builtin.func' +// CHECK: Visiting region 0 from operation 'builtin.module' // CHECK-LABEL: Op pre-order erasures // CHECK: Erasing op 'scf.for' @@ -100,15 +100,15 @@ // CHECK: Erasing op 'use3' // CHECK: Erasing op 'scf.for' // CHECK: Erasing op 'std.return' -// CHECK: Erasing op 'func' -// CHECK: Erasing op 'module' +// CHECK: Erasing op 'builtin.func' +// CHECK: Erasing op 'builtin.module' // CHECK-LABEL: Block post-order erasures (no skip) // CHECK: Erasing block ^bb0 from region 0 from operation 'scf.if' // CHECK: Erasing block ^bb0 from region 1 from operation 'scf.if' // CHECK: Erasing block ^bb0 from region 0 from operation 'scf.for' -// CHECK: Erasing block ^bb0 from region 0 from operation 'func' -// CHECK: Erasing block ^bb0 from region 0 from operation 'module' +// CHECK: Erasing block ^bb0 from region 0 from operation 'builtin.func' +// CHECK: Erasing block ^bb0 from region 0 from operation 'builtin.module' // ----- @@ -127,8 +127,8 @@ } // CHECK-LABEL: Op pre-order visits -// CHECK: Visiting op 'module' -// CHECK: Visiting op 'func' +// CHECK: Visiting op 'builtin.module' +// CHECK: Visiting op 'builtin.func' // CHECK: Visiting op 'regionOp0' // CHECK: Visiting op 'op0' // CHECK: Visiting op 'std.br' @@ -138,15 +138,15 @@ // CHECK: Visiting op 'std.return' // CHECK-LABEL: Block pre-order visits -// CHECK: Visiting block ^bb0 from region 0 from operation 'module' -// CHECK: Visiting block ^bb0 from region 0 from operation 'func' +// CHECK: Visiting block ^bb0 from region 0 from operation 'builtin.module' +// CHECK: Visiting block ^bb0 from region 0 from operation 'builtin.func' // CHECK: Visiting block ^bb0 from region 0 from operation 'regionOp0' // CHECK: Visiting block ^bb1 from region 0 from operation 'regionOp0' // CHECK: Visiting block ^bb2 from region 0 from operation 'regionOp0' // CHECK-LABEL: Region pre-order visits -// CHECK: Visiting region 0 from operation 'module' -// CHECK: Visiting region 0 from operation 'func' +// CHECK: Visiting region 0 from operation 'builtin.module' +// CHECK: Visiting region 0 from operation 'builtin.func' // CHECK: Visiting region 0 from operation 'regionOp0' // CHECK-LABEL: Op post-order visits @@ -157,20 +157,20 @@ // CHECK: Visiting op 'op2' // CHECK: Visiting op 'regionOp0' // CHECK: Visiting op 'std.return' -// CHECK: Visiting op 'func' -// CHECK: Visiting op 'module' +// CHECK: Visiting op 'builtin.func' +// CHECK: Visiting op 'builtin.module' // CHECK-LABEL: Block post-order visits // CHECK: Visiting block ^bb0 from region 0 from operation 'regionOp0' // CHECK: Visiting block ^bb1 from region 0 from operation 'regionOp0' // CHECK: Visiting block ^bb2 from region 0 from operation 'regionOp0' -// CHECK: Visiting block ^bb0 from region 0 from operation 'func' -// CHECK: Visiting block ^bb0 from region 0 from operation 'module' +// CHECK: Visiting block ^bb0 from region 0 from operation 'builtin.func' +// CHECK: Visiting block ^bb0 from region 0 from operation 'builtin.module' // CHECK-LABEL: Region post-order visits // CHECK: Visiting region 0 from operation 'regionOp0' -// CHECK: Visiting region 0 from operation 'func' -// CHECK: Visiting region 0 from operation 'module' +// CHECK: Visiting region 0 from operation 'builtin.func' +// CHECK: Visiting region 0 from operation 'builtin.module' // CHECK-LABEL: Op pre-order erasures (skip) // CHECK: Erasing op 'regionOp0' @@ -208,5 +208,5 @@ // CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0' // CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0' // CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0' -// CHECK: Erasing block ^bb0 from region 0 from operation 'func' -// CHECK: Erasing block ^bb0 from region 0 from operation 'module' +// CHECK: Erasing block ^bb0 from region 0 from operation 'builtin.func' +// CHECK: Erasing block ^bb0 from region 0 from operation 'builtin.module' diff --git a/mlir/test/IR/wrapping_op.mlir b/mlir/test/IR/wrapping_op.mlir --- a/mlir/test/IR/wrapping_op.mlir +++ b/mlir/test/IR/wrapping_op.mlir @@ -2,7 +2,7 @@ // RUN: mlir-opt -allow-unregistered-dialect -mlir-print-op-generic -mlir-print-debuginfo -mlir-print-local-scope %s | FileCheck %s --check-prefix=CHECK-GENERIC // CHECK-LABEL: func @wrapping_op -// CHECK-GENERIC: "func" +// CHECK-GENERIC: "builtin.func" func @wrapping_op(%arg0 : i32, %arg1 : f32) -> (i3, i2, i1) { // CHECK: %0:3 = test.wrapping_region wraps "some.op"(%arg1, %arg0) {test.attr = "attr"} : (f32, i32) -> (i1, i2, i3) // CHECK-GENERIC: "test.wrapping_region"() ( { diff --git a/mlir/test/Pass/crash-recovery.mlir b/mlir/test/Pass/crash-recovery.mlir --- a/mlir/test/Pass/crash-recovery.mlir +++ b/mlir/test/Pass/crash-recovery.mlir @@ -1,6 +1,6 @@ -// RUN: mlir-opt %s -pass-pipeline='module(test-module-pass, test-pass-crash)' -pass-pipeline-crash-reproducer=%t -verify-diagnostics +// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-module-pass, test-pass-crash)' -pass-pipeline-crash-reproducer=%t -verify-diagnostics // RUN: cat %t | FileCheck -check-prefix=REPRO %s -// RUN: mlir-opt %s -pass-pipeline='module(test-module-pass, test-pass-crash)' -pass-pipeline-crash-reproducer=%t -verify-diagnostics -pass-pipeline-local-reproducer -mlir-disable-threading +// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-module-pass, test-pass-crash)' -pass-pipeline-crash-reproducer=%t -verify-diagnostics -pass-pipeline-local-reproducer -mlir-disable-threading // RUN: cat %t | FileCheck -check-prefix=REPRO_LOCAL %s // Check that we correctly handle verifiers passes with local reproducer, this used to crash. @@ -17,17 +17,17 @@ module @foo {} } -// REPRO: configuration: -pass-pipeline='module(test-module-pass, test-pass-crash)' +// REPRO: configuration: -pass-pipeline='builtin.module(test-module-pass, test-pass-crash)' // REPRO: module @inner_mod1 // REPRO: module @foo { -// REPRO_LOCAL: configuration: -pass-pipeline='module(test-pass-crash)' +// REPRO_LOCAL: configuration: -pass-pipeline='builtin.module(test-pass-crash)' // REPRO_LOCAL: module @inner_mod1 // REPRO_LOCAL: module @foo { -// REPRO_LOCAL_DYNAMIC: configuration: -pass-pipeline='module(test-pass-crash)' +// REPRO_LOCAL_DYNAMIC: configuration: -pass-pipeline='builtin.module(test-pass-crash)' // REPRO_LOCAL_DYNAMIC: module @inner_mod1 // REPRO_LOCAL_DYNAMIC: module @foo { diff --git a/mlir/test/Pass/dynamic-pipeline-fail-on-parent.mlir b/mlir/test/Pass/dynamic-pipeline-fail-on-parent.mlir --- a/mlir/test/Pass/dynamic-pipeline-fail-on-parent.mlir +++ b/mlir/test/Pass/dynamic-pipeline-fail-on-parent.mlir @@ -1,8 +1,8 @@ -// RUN: mlir-opt %s -pass-pipeline='module(test-dynamic-pipeline{op-name=inner_mod1 run-on-parent=1 dynamic-pipeline=test-patterns})' -split-input-file -verify-diagnostics +// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod1 run-on-parent=1 dynamic-pipeline=test-patterns})' -split-input-file -verify-diagnostics // Verify that we fail to schedule a dynamic pipeline on the parent operation. -// expected-error @+1 {{'module' op Trying to schedule a dynamic pipeline on an operation that isn't nested under the current operation}} +// expected-error @+1 {{'builtin.module' op Trying to schedule a dynamic pipeline on an operation that isn't nested under the current operation}} module { module @inner_mod1 { "test.symbol"() {sym_name = "foo"} : () -> () diff --git a/mlir/test/Pass/dynamic-pipeline-nested.mlir b/mlir/test/Pass/dynamic-pipeline-nested.mlir --- a/mlir/test/Pass/dynamic-pipeline-nested.mlir +++ b/mlir/test/Pass/dynamic-pipeline-nested.mlir @@ -1,5 +1,5 @@ -// RUN: mlir-opt %s -pass-pipeline='module(test-dynamic-pipeline{op-name=inner_mod1 dynamic-pipeline=cse})' --mlir-disable-threading -print-ir-before-all 2>&1 | FileCheck %s --check-prefix=NOTNESTED --check-prefix=CHECK -// RUN: mlir-opt %s -pass-pipeline='module(test-dynamic-pipeline{op-name=inner_mod1 run-on-nested-operations=1 dynamic-pipeline=cse})' --mlir-disable-threading -print-ir-before-all 2>&1 | FileCheck %s --check-prefix=NESTED --check-prefix=CHECK +// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod1 dynamic-pipeline=cse})' --mlir-disable-threading -print-ir-before-all 2>&1 | FileCheck %s --check-prefix=NOTNESTED --check-prefix=CHECK +// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod1 run-on-nested-operations=1 dynamic-pipeline=cse})' --mlir-disable-threading -print-ir-before-all 2>&1 | FileCheck %s --check-prefix=NESTED --check-prefix=CHECK // Verify that we can schedule a dynamic pipeline on a nested operation diff --git a/mlir/test/Pass/dynamic-pipeline.mlir b/mlir/test/Pass/dynamic-pipeline.mlir --- a/mlir/test/Pass/dynamic-pipeline.mlir +++ b/mlir/test/Pass/dynamic-pipeline.mlir @@ -1,7 +1,7 @@ -// RUN: mlir-opt %s -pass-pipeline='module(test-dynamic-pipeline{op-name=inner_mod1, dynamic-pipeline=func(cse,canonicalize)})' --mlir-disable-threading -print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD1 --check-prefix=MOD1-ONLY --check-prefix=CHECK -// RUN: mlir-opt %s -pass-pipeline='module(test-dynamic-pipeline{op-name=inner_mod2, dynamic-pipeline=func(cse,canonicalize)})' --mlir-disable-threading -print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD2 --check-prefix=MOD2-ONLY --check-prefix=CHECK -// RUN: mlir-opt %s -pass-pipeline='module(test-dynamic-pipeline{op-name=inner_mod1,inner_mod2, dynamic-pipeline=func(cse,canonicalize)})' --mlir-disable-threading -print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD1 --check-prefix=MOD2 --check-prefix=CHECK -// RUN: mlir-opt %s -pass-pipeline='module(test-dynamic-pipeline{dynamic-pipeline=func(cse,canonicalize)})' --mlir-disable-threading -print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD1 --check-prefix=MOD2 --check-prefix=CHECK +// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod1, dynamic-pipeline=builtin.func(cse,canonicalize)})' --mlir-disable-threading -print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD1 --check-prefix=MOD1-ONLY --check-prefix=CHECK +// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod2, dynamic-pipeline=builtin.func(cse,canonicalize)})' --mlir-disable-threading -print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD2 --check-prefix=MOD2-ONLY --check-prefix=CHECK +// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod1,inner_mod2, dynamic-pipeline=builtin.func(cse,canonicalize)})' --mlir-disable-threading -print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD1 --check-prefix=MOD2 --check-prefix=CHECK +// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{dynamic-pipeline=builtin.func(cse,canonicalize)})' --mlir-disable-threading -print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD1 --check-prefix=MOD2 --check-prefix=CHECK func @f() { diff --git a/mlir/test/Pass/invalid-pass.mlir b/mlir/test/Pass/invalid-pass.mlir --- a/mlir/test/Pass/invalid-pass.mlir +++ b/mlir/test/Pass/invalid-pass.mlir @@ -1,6 +1,6 @@ -// RUN: not mlir-opt %s -pass-pipeline='module(test-module-pass{test-option=a})' 2>&1 | FileCheck %s +// RUN: not mlir-opt %s -pass-pipeline='builtin.module(test-module-pass{test-option=a})' 2>&1 | FileCheck %s // CHECK: : no such option test-option // CHECK: failed to add `test-module-pass` with options `test-option=a` -// CHECK: failed to add `module` with options `` to inner pipeline +// CHECK: failed to add `builtin.module` with options `` to inner pipeline module {} diff --git a/mlir/test/Pass/ir-printing.mlir b/mlir/test/Pass/ir-printing.mlir --- a/mlir/test/Pass/ir-printing.mlir +++ b/mlir/test/Pass/ir-printing.mlir @@ -1,10 +1,10 @@ -// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func(cse,canonicalize)' -print-ir-before=cse -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE %s -// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func(cse,canonicalize)' -print-ir-before-all -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_ALL %s -// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func(cse,canonicalize)' -print-ir-after=cse -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER %s -// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func(cse,canonicalize)' -print-ir-after-all -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL %s -// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func(cse,canonicalize)' -print-ir-before=cse -print-ir-module-scope -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_MODULE %s -// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func(cse,cse)' -print-ir-after-all -print-ir-after-change -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL_CHANGE %s -// RUN: not mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func(cse,test-pass-failure)' -print-ir-after-failure -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_FAILURE %s +// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.func(cse,canonicalize)' -print-ir-before=cse -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE %s +// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.func(cse,canonicalize)' -print-ir-before-all -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_ALL %s +// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.func(cse,canonicalize)' -print-ir-after=cse -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER %s +// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.func(cse,canonicalize)' -print-ir-after-all -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL %s +// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.func(cse,canonicalize)' -print-ir-before=cse -print-ir-module-scope -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_MODULE %s +// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.func(cse,cse)' -print-ir-after-all -print-ir-after-change -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL_CHANGE %s +// RUN: not mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.func(cse,test-pass-failure)' -print-ir-after-failure -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_FAILURE %s func @foo() { %0 = constant 0 : i32 @@ -49,10 +49,10 @@ // AFTER_ALL: // -----// IR Dump After{{.*}}Canonicalizer //----- // // AFTER_ALL-NEXT: func @bar() -// BEFORE_MODULE: // -----// IR Dump Before{{.*}}CSE ('func' operation: @foo) //----- // +// BEFORE_MODULE: // -----// IR Dump Before{{.*}}CSE ('builtin.func' operation: @foo) //----- // // BEFORE_MODULE: func @foo() // BEFORE_MODULE: func @bar() -// BEFORE_MODULE: // -----// IR Dump Before{{.*}}CSE ('func' operation: @bar) //----- // +// BEFORE_MODULE: // -----// IR Dump Before{{.*}}CSE ('builtin.func' operation: @bar) //----- // // BEFORE_MODULE: func @foo() // BEFORE_MODULE: func @bar() diff --git a/mlir/test/Pass/pass-timing.mlir b/mlir/test/Pass/pass-timing.mlir --- a/mlir/test/Pass/pass-timing.mlir +++ b/mlir/test/Pass/pass-timing.mlir @@ -1,7 +1,7 @@ -// RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=true -pass-pipeline='func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=list 2>&1 | FileCheck -check-prefix=LIST %s -// RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=true -pass-pipeline='func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck -check-prefix=PIPELINE %s -// RUN: mlir-opt %s -mlir-disable-threading=false -verify-each=true -pass-pipeline='func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=list 2>&1 | FileCheck -check-prefix=MT_LIST %s -// RUN: mlir-opt %s -mlir-disable-threading=false -verify-each=true -pass-pipeline='func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck -check-prefix=MT_PIPELINE %s +// RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=true -pass-pipeline='builtin.func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=list 2>&1 | FileCheck -check-prefix=LIST %s +// RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=true -pass-pipeline='builtin.func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck -check-prefix=PIPELINE %s +// RUN: mlir-opt %s -mlir-disable-threading=false -verify-each=true -pass-pipeline='builtin.func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=list 2>&1 | FileCheck -check-prefix=MT_LIST %s +// RUN: mlir-opt %s -mlir-disable-threading=false -verify-each=true -pass-pipeline='builtin.func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck -check-prefix=MT_PIPELINE %s // RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=false -test-pm-nested-pipeline -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck -check-prefix=NESTED_PIPELINE %s // LIST: Execution time report @@ -16,7 +16,7 @@ // PIPELINE: Total Execution Time: // PIPELINE: Name // PIPELINE-NEXT: Parser -// PIPELINE-NEXT: 'func' Pipeline +// PIPELINE-NEXT: 'builtin.func' Pipeline // PIPELINE-NEXT: CSE // PIPELINE-NEXT: (A) DominanceInfo // PIPELINE-NEXT: Canonicalizer @@ -38,7 +38,7 @@ // MT_PIPELINE: Total Execution Time: // MT_PIPELINE: Name // MT_PIPELINE-NEXT: Parser -// MT_PIPELINE-NEXT: 'func' Pipeline +// MT_PIPELINE-NEXT: 'builtin.func' Pipeline // MT_PIPELINE-NEXT: CSE // MT_PIPELINE-NEXT: (A) DominanceInfo // MT_PIPELINE-NEXT: Canonicalizer @@ -52,12 +52,12 @@ // NESTED_PIPELINE: Total Execution Time: // NESTED_PIPELINE: Name // NESTED_PIPELINE-NEXT: Parser -// NESTED_PIPELINE-NEXT: Pipeline Collection : ['func', 'module'] -// NESTED_PIPELINE-NEXT: 'func' Pipeline +// NESTED_PIPELINE-NEXT: Pipeline Collection : ['builtin.func', 'builtin.module'] +// NESTED_PIPELINE-NEXT: 'builtin.func' Pipeline // NESTED_PIPELINE-NEXT: TestFunctionPass -// NESTED_PIPELINE-NEXT: 'module' Pipeline +// NESTED_PIPELINE-NEXT: 'builtin.module' Pipeline // NESTED_PIPELINE-NEXT: TestModulePass -// NESTED_PIPELINE-NEXT: 'func' Pipeline +// NESTED_PIPELINE-NEXT: 'builtin.func' Pipeline // NESTED_PIPELINE-NEXT: TestFunctionPass // NESTED_PIPELINE-NEXT: Output // NESTED_PIPELINE-NEXT: Rest diff --git a/mlir/test/Pass/pipeline-options-parsing.mlir b/mlir/test/Pass/pipeline-options-parsing.mlir --- a/mlir/test/Pass/pipeline-options-parsing.mlir +++ b/mlir/test/Pass/pipeline-options-parsing.mlir @@ -1,11 +1,11 @@ -// RUN: not mlir-opt %s -pass-pipeline='module(test-module-pass{)' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_1 %s -// RUN: not mlir-opt %s -pass-pipeline='module(test-module-pass{test-option=3})' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_2 %s -// RUN: not mlir-opt %s -pass-pipeline='module(func(test-options-pass{list=3}), test-module-pass{invalid-option=3})' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_3 %s +// RUN: not mlir-opt %s -pass-pipeline='builtin.module(test-module-pass{)' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_1 %s +// RUN: not mlir-opt %s -pass-pipeline='builtin.module(test-module-pass{test-option=3})' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_2 %s +// RUN: not mlir-opt %s -pass-pipeline='builtin.module(builtin.func(test-options-pass{list=3}), test-module-pass{invalid-option=3})' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_3 %s // RUN: not mlir-opt %s -pass-pipeline='test-options-pass{list=3 list=notaninteger}' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_4 %s -// RUN: not mlir-opt %s -pass-pipeline='func(test-options-pass{list=1,2,3,4 list=5 string=value1 string=value2})' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_5 %s -// RUN: mlir-opt %s -verify-each=false -pass-pipeline='func(test-options-pass{string-list=a list=1,2,3,4 string-list=b,c list=5 string-list=d string=some_value})' -test-dump-pipeline 2>&1 | FileCheck --check-prefix=CHECK_1 %s +// RUN: not mlir-opt %s -pass-pipeline='builtin.func(test-options-pass{list=1,2,3,4 list=5 string=value1 string=value2})' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_5 %s +// RUN: mlir-opt %s -verify-each=false -pass-pipeline='builtin.func(test-options-pass{string-list=a list=1,2,3,4 string-list=b,c list=5 string-list=d string=some_value})' -test-dump-pipeline 2>&1 | FileCheck --check-prefix=CHECK_1 %s // RUN: mlir-opt %s -verify-each=false -test-options-pass-pipeline='list=1 string-list=a,b' -test-dump-pipeline 2>&1 | FileCheck --check-prefix=CHECK_2 %s -// RUN: mlir-opt %s -verify-each=false -pass-pipeline='module(func(test-options-pass{list=3}), func(test-options-pass{list=1,2,3,4}))' -test-dump-pipeline 2>&1 | FileCheck --check-prefix=CHECK_3 %s +// RUN: mlir-opt %s -verify-each=false -pass-pipeline='builtin.module(builtin.func(test-options-pass{list=3}), builtin.func(test-options-pass{list=1,2,3,4}))' -test-dump-pipeline 2>&1 | FileCheck --check-prefix=CHECK_3 %s // CHECK_ERROR_1: missing closing '}' while processing pass options // CHECK_ERROR_2: no such option test-option @@ -15,4 +15,4 @@ // CHECK_1: test-options-pass{list=1,2,3,4,5 string=some_value string-list=a,b,c,d} // CHECK_2: test-options-pass{list=1 string= string-list=a,b} -// CHECK_3: module(func(test-options-pass{list=3 string= }), func(test-options-pass{list=1,2,3,4 string= })) +// CHECK_3: builtin.module(builtin.func(test-options-pass{list=3 string= }), builtin.func(test-options-pass{list=1,2,3,4 string= })) diff --git a/mlir/test/Pass/pipeline-parsing.mlir b/mlir/test/Pass/pipeline-parsing.mlir --- a/mlir/test/Pass/pipeline-parsing.mlir +++ b/mlir/test/Pass/pipeline-parsing.mlir @@ -1,16 +1,16 @@ -// RUN: mlir-opt %s -mlir-disable-threading -pass-pipeline='module(test-module-pass,func(test-function-pass)),func(test-function-pass)' -pass-pipeline="func(cse,canonicalize)" -verify-each=false -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck %s +// RUN: mlir-opt %s -mlir-disable-threading -pass-pipeline='builtin.module(test-module-pass,builtin.func(test-function-pass)),builtin.func(test-function-pass)' -pass-pipeline="builtin.func(cse,canonicalize)" -verify-each=false -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck %s // RUN: mlir-opt %s -mlir-disable-threading -test-textual-pm-nested-pipeline -verify-each=false -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck %s --check-prefix=TEXTUAL_CHECK -// RUN: not mlir-opt %s -pass-pipeline='module(test-module-pass' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_1 %s -// RUN: not mlir-opt %s -pass-pipeline='module(test-module-pass))' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_2 %s -// RUN: not mlir-opt %s -pass-pipeline='module()(' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_3 %s +// RUN: not mlir-opt %s -pass-pipeline='builtin.module(test-module-pass' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_1 %s +// RUN: not mlir-opt %s -pass-pipeline='builtin.module(test-module-pass))' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_2 %s +// RUN: not mlir-opt %s -pass-pipeline='builtin.module()(' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_3 %s // RUN: not mlir-opt %s -pass-pipeline=',' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_4 %s -// RUN: not mlir-opt %s -pass-pipeline='func(test-module-pass)' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_5 %s +// RUN: not mlir-opt %s -pass-pipeline='builtin.func(test-module-pass)' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_5 %s // CHECK_ERROR_1: encountered unbalanced parentheses while parsing pipeline // CHECK_ERROR_2: encountered extra closing ')' creating unbalanced parentheses while parsing pipeline // CHECK_ERROR_3: expected ',' after parsing pipeline // CHECK_ERROR_4: does not refer to a registered pass or pass pipeline -// CHECK_ERROR_5: Can't add pass '{{.*}}TestModulePass' restricted to 'module' on a PassManager intended to run on 'func', did you intend to nest? +// CHECK_ERROR_5: Can't add pass '{{.*}}TestModulePass' restricted to 'builtin.module' on a PassManager intended to run on 'builtin.func', did you intend to nest? func @foo() { return } @@ -21,21 +21,21 @@ } } -// CHECK: Pipeline Collection : ['func', 'module'] -// CHECK-NEXT: 'func' Pipeline +// CHECK: Pipeline Collection : ['builtin.func', 'builtin.module'] +// CHECK-NEXT: 'builtin.func' Pipeline // CHECK-NEXT: TestFunctionPass // CHECK-NEXT: CSE // CHECK-NEXT: DominanceInfo // CHECK-NEXT: Canonicalizer -// CHECK-NEXT: 'module' Pipeline +// CHECK-NEXT: 'builtin.module' Pipeline // CHECK-NEXT: TestModulePass -// CHECK-NEXT: 'func' Pipeline +// CHECK-NEXT: 'builtin.func' Pipeline // CHECK-NEXT: TestFunctionPass -// TEXTUAL_CHECK: Pipeline Collection : ['func', 'module'] -// TEXTUAL_CHECK-NEXT: 'func' Pipeline +// TEXTUAL_CHECK: Pipeline Collection : ['builtin.func', 'builtin.module'] +// TEXTUAL_CHECK-NEXT: 'builtin.func' Pipeline // TEXTUAL_CHECK-NEXT: TestFunctionPass -// TEXTUAL_CHECK-NEXT: 'module' Pipeline +// TEXTUAL_CHECK-NEXT: 'builtin.module' Pipeline // TEXTUAL_CHECK-NEXT: TestModulePass -// TEXTUAL_CHECK-NEXT: 'func' Pipeline +// TEXTUAL_CHECK-NEXT: 'builtin.func' Pipeline // TEXTUAL_CHECK-NEXT: TestFunctionPass diff --git a/mlir/test/Pass/pipeline-stats.mlir b/mlir/test/Pass/pipeline-stats.mlir --- a/mlir/test/Pass/pipeline-stats.mlir +++ b/mlir/test/Pass/pipeline-stats.mlir @@ -1,6 +1,6 @@ // REQUIRES: asserts -// RUN: mlir-opt %s -verify-each=true -pass-pipeline='func(test-stats-pass,test-stats-pass)' -pass-statistics -pass-statistics-display=list 2>&1 | FileCheck -check-prefix=LIST %s -// RUN: mlir-opt %s -verify-each=true -pass-pipeline='func(test-stats-pass,test-stats-pass)' -pass-statistics -pass-statistics-display=pipeline 2>&1 | FileCheck -check-prefix=PIPELINE %s +// RUN: mlir-opt %s -verify-each=true -pass-pipeline='builtin.func(test-stats-pass,test-stats-pass)' -pass-statistics -pass-statistics-display=list 2>&1 | FileCheck -check-prefix=LIST %s +// RUN: mlir-opt %s -verify-each=true -pass-pipeline='builtin.func(test-stats-pass,test-stats-pass)' -pass-statistics -pass-statistics-display=pipeline 2>&1 | FileCheck -check-prefix=PIPELINE %s // LIST: Pass statistics report // LIST: TestStatisticPass @@ -8,7 +8,7 @@ // LIST-NOT: Verifier // PIPELINE: Pass statistics report -// PIPELINE: 'func' Pipeline +// PIPELINE: 'builtin.func' Pipeline // PIPELINE-NEXT: TestStatisticPass // PIPELINE-NEXT: (S) {{0|4}} num-ops - Number of operations counted // PIPELINE-NEXT: TestStatisticPass diff --git a/mlir/test/Pass/run-reproducer.mlir b/mlir/test/Pass/run-reproducer.mlir --- a/mlir/test/Pass/run-reproducer.mlir +++ b/mlir/test/Pass/run-reproducer.mlir @@ -1,4 +1,4 @@ -// configuration: -mlir-disable-threading=true -pass-pipeline='func(cse,canonicalize)' -print-ir-before=cse +// configuration: -mlir-disable-threading=true -pass-pipeline='builtin.func(cse,canonicalize)' -print-ir-before=cse // Test of the reproducer run option. The first line has to be the // configuration (matching what is produced by reproducer). diff --git a/mlir/test/Transforms/canonicalize-block-merge.mlir b/mlir/test/Transforms/canonicalize-block-merge.mlir --- a/mlir/test/Transforms/canonicalize-block-merge.mlir +++ b/mlir/test/Transforms/canonicalize-block-merge.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func(canonicalize)' -split-input-file | FileCheck %s +// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='builtin.func(canonicalize)' -split-input-file | FileCheck %s // Check the simple case of single operation blocks with a return. diff --git a/mlir/test/Transforms/canonicalize-dce.mlir b/mlir/test/Transforms/canonicalize-dce.mlir --- a/mlir/test/Transforms/canonicalize-dce.mlir +++ b/mlir/test/Transforms/canonicalize-dce.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -pass-pipeline='func(canonicalize)' | FileCheck %s +// RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -pass-pipeline='builtin.func(canonicalize)' | FileCheck %s // Test case: Simple case of deleting a dead pure op. diff --git a/mlir/test/Transforms/canonicalize-td.mlir b/mlir/test/Transforms/canonicalize-td.mlir --- a/mlir/test/Transforms/canonicalize-td.mlir +++ b/mlir/test/Transforms/canonicalize-td.mlir @@ -1,5 +1,5 @@ -// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func(canonicalize{top-down=true})' | FileCheck %s --check-prefix=TD -// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func(canonicalize)' | FileCheck %s --check-prefix=BU +// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='builtin.func(canonicalize{top-down=true})' | FileCheck %s --check-prefix=TD +// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='builtin.func(canonicalize)' | FileCheck %s --check-prefix=BU // BU-LABEL: func @default_insertion_position diff --git a/mlir/test/Transforms/canonicalize.mlir b/mlir/test/Transforms/canonicalize.mlir --- a/mlir/test/Transforms/canonicalize.mlir +++ b/mlir/test/Transforms/canonicalize.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func(canonicalize)' -split-input-file | FileCheck %s +// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='builtin.func(canonicalize)' -split-input-file | FileCheck %s // CHECK-LABEL: func @test_subi_zero func @test_subi_zero(%arg0: i32) -> i32 { diff --git a/mlir/test/Transforms/cse.mlir b/mlir/test/Transforms/cse.mlir --- a/mlir/test/Transforms/cse.mlir +++ b/mlir/test/Transforms/cse.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func(cse)' | FileCheck %s +// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='builtin.func(cse)' | FileCheck %s // CHECK-DAG: #[[$MAP:.*]] = affine_map<(d0) -> (d0 mod 2)> #map0 = affine_map<(d0) -> (d0 mod 2)> diff --git a/mlir/test/Transforms/parallel-loop-collapsing.mlir b/mlir/test/Transforms/parallel-loop-collapsing.mlir --- a/mlir/test/Transforms/parallel-loop-collapsing.mlir +++ b/mlir/test/Transforms/parallel-loop-collapsing.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func(parallel-loop-collapsing{collapsed-indices-0=0,3 collapsed-indices-1=1,4 collapsed-indices-2=2}, canonicalize)' | FileCheck %s +// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='builtin.func(parallel-loop-collapsing{collapsed-indices-0=0,3 collapsed-indices-1=1,4 collapsed-indices-2=2}, canonicalize)' | FileCheck %s // CHECK-LABEL: func @parallel_many_dims() { func @parallel_many_dims() { diff --git a/mlir/test/Transforms/sccp-callgraph.mlir b/mlir/test/Transforms/sccp-callgraph.mlir --- a/mlir/test/Transforms/sccp-callgraph.mlir +++ b/mlir/test/Transforms/sccp-callgraph.mlir @@ -1,5 +1,5 @@ // RUN: mlir-opt -allow-unregistered-dialect %s -sccp -split-input-file | FileCheck %s -// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="module(sccp)" -split-input-file | FileCheck %s --check-prefix=NESTED +// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="builtin.module(sccp)" -split-input-file | FileCheck %s --check-prefix=NESTED /// Check that a constant is properly propagated through the arguments and /// results of a private function. diff --git a/mlir/test/Transforms/sccp-structured.mlir b/mlir/test/Transforms/sccp-structured.mlir --- a/mlir/test/Transforms/sccp-structured.mlir +++ b/mlir/test/Transforms/sccp-structured.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="func(sccp)" -split-input-file | FileCheck %s +// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="builtin.func(sccp)" -split-input-file | FileCheck %s /// Check that a constant is properly propagated when only one edge is taken. diff --git a/mlir/test/Transforms/sccp.mlir b/mlir/test/Transforms/sccp.mlir --- a/mlir/test/Transforms/sccp.mlir +++ b/mlir/test/Transforms/sccp.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="func(sccp)" -split-input-file | FileCheck %s +// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="builtin.func(sccp)" -split-input-file | FileCheck %s /// Check simple forward constant propagation without any control flow. diff --git a/mlir/test/Transforms/single-parallel-loop-collapsing.mlir b/mlir/test/Transforms/single-parallel-loop-collapsing.mlir --- a/mlir/test/Transforms/single-parallel-loop-collapsing.mlir +++ b/mlir/test/Transforms/single-parallel-loop-collapsing.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func(parallel-loop-collapsing{collapsed-indices-0=0,1}, canonicalize)' | FileCheck %s +// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='builtin.func(parallel-loop-collapsing{collapsed-indices-0=0,1}, canonicalize)' | FileCheck %s func @collapse_to_single() { %c0 = constant 3 : index diff --git a/mlir/test/Transforms/test-canonicalize-filter.mlir b/mlir/test/Transforms/test-canonicalize-filter.mlir --- a/mlir/test/Transforms/test-canonicalize-filter.mlir +++ b/mlir/test/Transforms/test-canonicalize-filter.mlir @@ -1,6 +1,6 @@ -// RUN: mlir-opt %s -pass-pipeline='func(canonicalize)' | FileCheck %s --check-prefix=NO_FILTER -// RUN: mlir-opt %s -pass-pipeline='func(canonicalize{enable-patterns=TestRemoveOpWithInnerOps})' | FileCheck %s --check-prefix=FILTER_ENABLE -// RUN: mlir-opt %s -pass-pipeline='func(canonicalize{disable-patterns=TestRemoveOpWithInnerOps})' | FileCheck %s --check-prefix=FILTER_DISABLE +// RUN: mlir-opt %s -pass-pipeline='builtin.func(canonicalize)' | FileCheck %s --check-prefix=NO_FILTER +// RUN: mlir-opt %s -pass-pipeline='builtin.func(canonicalize{enable-patterns=TestRemoveOpWithInnerOps})' | FileCheck %s --check-prefix=FILTER_ENABLE +// RUN: mlir-opt %s -pass-pipeline='builtin.func(canonicalize{disable-patterns=TestRemoveOpWithInnerOps})' | FileCheck %s --check-prefix=FILTER_DISABLE // NO_FILTER-LABEL: func @remove_op_with_inner_ops_pattern // NO_FILTER-NEXT: return diff --git a/mlir/test/Transforms/test-canonicalize.mlir b/mlir/test/Transforms/test-canonicalize.mlir --- a/mlir/test/Transforms/test-canonicalize.mlir +++ b/mlir/test/Transforms/test-canonicalize.mlir @@ -1,4 +1,4 @@ -// RUN: mlir-opt %s -pass-pipeline='func(canonicalize)' | FileCheck %s +// RUN: mlir-opt %s -pass-pipeline='builtin.func(canonicalize)' | FileCheck %s // CHECK-LABEL: func @remove_op_with_inner_ops_pattern func @remove_op_with_inner_ops_pattern() { diff --git a/mlir/test/Transforms/test-legalizer-analysis.mlir b/mlir/test/Transforms/test-legalizer-analysis.mlir --- a/mlir/test/Transforms/test-legalizer-analysis.mlir +++ b/mlir/test/Transforms/test-legalizer-analysis.mlir @@ -1,7 +1,7 @@ // RUN: mlir-opt -allow-unregistered-dialect -test-legalize-patterns -verify-diagnostics -test-legalize-mode=analysis %s | FileCheck %s -// expected-remark@-2 {{op 'module' is legalizable}} +// expected-remark@-2 {{op 'builtin.module' is legalizable}} -// expected-remark@+1 {{op 'func' is legalizable}} +// expected-remark@+1 {{op 'builtin.func' is legalizable}} func @test(%arg0: f32) { // expected-remark@+1 {{op 'test.illegal_op_a' is legalizable}} %result = "test.illegal_op_a"() : () -> (i32) diff --git a/mlir/test/Transforms/test-symbol-dce.mlir b/mlir/test/Transforms/test-symbol-dce.mlir --- a/mlir/test/Transforms/test-symbol-dce.mlir +++ b/mlir/test/Transforms/test-symbol-dce.mlir @@ -1,5 +1,5 @@ // RUN: mlir-opt -allow-unregistered-dialect %s -symbol-dce -split-input-file -verify-diagnostics | FileCheck %s -// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="module(symbol-dce)" -split-input-file | FileCheck %s --check-prefix=NESTED +// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="builtin.module(symbol-dce)" -split-input-file | FileCheck %s --check-prefix=NESTED // Check that trivially dead and trivially live non-nested cases are handled. diff --git a/mlir/test/mlir-lsp-server/diagnostics.test b/mlir/test/mlir-lsp-server/diagnostics.test --- a/mlir/test/mlir-lsp-server/diagnostics.test +++ b/mlir/test/mlir-lsp-server/diagnostics.test @@ -12,7 +12,7 @@ // CHECK-NEXT: "diagnostics": [ // CHECK-NEXT: { // CHECK-NEXT: "category": "Parse Error", -// CHECK-NEXT: "message": "custom op 'func' expected valid '@'-identifier for symbol name", +// CHECK-NEXT: "message": "custom op 'builtin.func' expected valid '@'-identifier for symbol name", // CHECK-NEXT: "range": { // CHECK-NEXT: "end": { // CHECK-NEXT: "character": 7, diff --git a/mlir/test/mlir-lsp-server/document-symbols.test b/mlir/test/mlir-lsp-server/document-symbols.test --- a/mlir/test/mlir-lsp-server/document-symbols.test +++ b/mlir/test/mlir-lsp-server/document-symbols.test @@ -42,7 +42,7 @@ // CHECK-NEXT: } // CHECK-NEXT: ], // CHECK-NEXT: "kind": 3, -// CHECK-NEXT: "name": "", +// CHECK-NEXT: "name": "", // CHECK-NEXT: "range": { // CHECK-NEXT: "end": { // CHECK-NEXT: "character": {{.*}}, diff --git a/mlir/test/mlir-lsp-server/hover.test b/mlir/test/mlir-lsp-server/hover.test --- a/mlir/test/mlir-lsp-server/hover.test +++ b/mlir/test/mlir-lsp-server/hover.test @@ -66,7 +66,7 @@ // CHECK-NEXT: "result": { // CHECK-NEXT: "contents": { // CHECK-NEXT: "kind": "markdown", -// CHECK-NEXT: "value": "Operation: \"func\"\n\nBlock #1\n\nPredecessors: \n\n" +// CHECK-NEXT: "value": "Operation: \"builtin.func\"\n\nBlock #1\n\nPredecessors: \n\n" // CHECK-NEXT: }, // CHECK-NEXT: "range": { // CHECK-NEXT: "end": { @@ -90,7 +90,7 @@ // CHECK-NEXT: "result": { // CHECK-NEXT: "contents": { // CHECK-NEXT: "kind": "markdown", -// CHECK-NEXT: "value": "Operation: \"func\"\n\nBlock: \n\nArgument #0\n\nType: `i1`\n\n" +// CHECK-NEXT: "value": "Operation: \"builtin.func\"\n\nBlock: \n\nArgument #0\n\nType: `i1`\n\n" // CHECK-NEXT: }, // CHECK-NEXT: "range": { // CHECK-NEXT: "end": { @@ -114,7 +114,7 @@ // CHECK-NEXT: "result": { // CHECK-NEXT: "contents": { // CHECK-NEXT: "kind": "markdown", -// CHECK-NEXT: "value": "\"func\" : public @foo\n\nGeneric Form:\n\n```mlir\n\"func\"() ( {\n}) {sym_name = \"foo\", type = (i1) -> ()} : () -> ()\n```\n" +// CHECK-NEXT: "value": "\"builtin.func\" : public @foo\n\nGeneric Form:\n\n```mlir\n\"builtin.func\"() ( {\n}) {sym_name = \"foo\", type = (i1) -> ()} : () -> ()\n```\n" // CHECK-NEXT: }, // CHECK-NEXT: "range": { // CHECK-NEXT: "end": { @@ -138,7 +138,7 @@ // CHECK-NEXT: "result": { // CHECK-NEXT: "contents": { // CHECK-NEXT: "kind": "markdown", -// CHECK-NEXT: "value": "\"func\" : public @foo\n\nGeneric Form:\n\n```mlir\n\"func\"() ( {\n}) {sym_name = \"foo\", type = (i1) -> ()} : () -> ()\n```\n" +// CHECK-NEXT: "value": "\"builtin.func\" : public @foo\n\nGeneric Form:\n\n```mlir\n\"builtin.func\"() ( {\n}) {sym_name = \"foo\", type = (i1) -> ()} : () -> ()\n```\n" // CHECK-NEXT: }, // CHECK-NEXT: "range": { // CHECK-NEXT: "end": { diff --git a/mlir/test/mlir-opt/commandline.mlir b/mlir/test/mlir-opt/commandline.mlir --- a/mlir/test/mlir-opt/commandline.mlir +++ b/mlir/test/mlir-opt/commandline.mlir @@ -6,6 +6,7 @@ // CHECK-NEXT: arm_neon // CHECK-NEXT: arm_sve // CHECK-NEXT: async +// CHECK-NEXT: builtin // CHECK-NEXT: complex // CHECK-NEXT: dlti // CHECK-NEXT: emitc diff --git a/mlir/test/python/integration/dialects/linalg/opsrun.py b/mlir/test/python/integration/dialects/linalg/opsrun.py --- a/mlir/test/python/integration/dialects/linalg/opsrun.py +++ b/mlir/test/python/integration/dialects/linalg/opsrun.py @@ -125,9 +125,10 @@ mod = Module.parse( str(module.operation.regions[0].blocks[0].operations[0].operation) + boilerplate) - pm = PassManager.parse("func(convert-linalg-to-loops, lower-affine, " + - "convert-scf-to-std), convert-vector-to-llvm," + - "convert-memref-to-llvm,convert-std-to-llvm") + pm = PassManager.parse( + "builtin.func(convert-linalg-to-loops, lower-affine, " + + "convert-scf-to-std), convert-vector-to-llvm," + + "convert-memref-to-llvm,convert-std-to-llvm") pm.run(mod) return mod diff --git a/mlir/test/python/ir/dialects.py b/mlir/test/python/ir/dialects.py --- a/mlir/test/python/ir/dialects.py +++ b/mlir/test/python/ir/dialects.py @@ -35,9 +35,7 @@ ctx = Context() # Access using attribute. d = ctx.dialects.std - # Note that the standard dialect namespace prints as ''. Others will print - # as " + # CHECK: print(d) try: _ = ctx.dialects.not_existing @@ -48,7 +46,7 @@ # Access using index. d = ctx.dialects["std"] - # CHECK: + # CHECK: print(d) try: _ = ctx.dialects["not_existing"] @@ -59,7 +57,7 @@ # Using the 'd' alias. d = ctx.d["std"] - # CHECK: + # CHECK: print(d) diff --git a/mlir/test/python/ir/operation.py b/mlir/test/python/ir/operation.py --- a/mlir/test/python/ir/operation.py +++ b/mlir/test/python/ir/operation.py @@ -580,7 +580,7 @@ def testPrintInvalidOperation(): ctx = Context() with Location.unknown(ctx): - module = Operation.create("module", regions=2) + module = Operation.create("builtin.module", regions=2) # This module has two region and is invalid verify that we fallback # to the generic printer for safety. block = module.regions[0].blocks.append() @@ -598,22 +598,22 @@ ctx = Context() with Location.unknown(ctx): try: - Operation.create("module", attributes={None:StringAttr.get("name")}) + Operation.create("builtin.module", attributes={None:StringAttr.get("name")}) except Exception as e: # CHECK: Invalid attribute key (not a string) when attempting to create the operation "module" print(e) try: - Operation.create("module", attributes={42:StringAttr.get("name")}) + Operation.create("builtin.module", attributes={42:StringAttr.get("name")}) except Exception as e: # CHECK: Invalid attribute key (not a string) when attempting to create the operation "module" print(e) try: - Operation.create("module", attributes={"some_key":ctx}) + Operation.create("builtin.module", attributes={"some_key":ctx}) except Exception as e: # CHECK: Invalid attribute value for the key "some_key" when attempting to create the operation "module" print(e) try: - Operation.create("module", attributes={"some_key":None}) + Operation.create("builtin.module", attributes={"some_key":None}) except Exception as e: # CHECK: Found an invalid (`None`?) attribute value for the key "some_key" when attempting to create the operation "module" print(e) diff --git a/mlir/test/python/pass_manager.py b/mlir/test/python/pass_manager.py --- a/mlir/test/python/pass_manager.py +++ b/mlir/test/python/pass_manager.py @@ -36,19 +36,19 @@ # A first import is expected to fail because the pass isn't registered # until we import mlir.transforms try: - pm = PassManager.parse("module(func(print-op-stats))") + pm = PassManager.parse("builtin.module(builtin.func(print-op-stats))") # TODO: this error should be propagate to Python but the C API does not help right now. # CHECK: error: 'print-op-stats' does not refer to a registered pass or pass pipeline except ValueError as e: - # CHECK: ValueError exception: invalid pass pipeline 'module(func(print-op-stats))'. + # CHECK: ValueError exception: invalid pass pipeline 'builtin.module(builtin.func(print-op-stats))'. log("ValueError exception:", e) else: log("Exception not produced") # This will register the pass and round-trip should be possible now. import mlir.transforms - pm = PassManager.parse("module(func(print-op-stats))") - # CHECK: Roundtrip: module(func(print-op-stats)) + pm = PassManager.parse("builtin.module(builtin.func(print-op-stats))") + # CHECK: Roundtrip: builtin.module(builtin.func(print-op-stats)) log("Roundtrip: ", pm) run(testParseSuccess) @@ -71,10 +71,10 @@ def testInvalidNesting(): with Context(): try: - pm = PassManager.parse("func(view-op-graph)") + pm = PassManager.parse("builtin.func(view-op-graph)") except ValueError as e: - # CHECK: Can't add pass 'ViewOpGraphPass' restricted to 'module' on a PassManager intended to run on 'func', did you intend to nest? - # CHECK: ValueError exception: invalid pass pipeline 'func(view-op-graph)'. + # CHECK: Can't add pass 'ViewOpGraphPass' restricted to 'builtin.module' on a PassManager intended to run on 'builtin.func', did you intend to nest? + # CHECK: ValueError exception: invalid pass pipeline 'builtin.func(view-op-graph)'. log("ValueError exception:", e) else: log("Exception not produced") @@ -89,7 +89,7 @@ module = Module.parse(r"""func @successfulParse() { return }""") pm.run(module) # CHECK: Operations encountered: -# CHECK: func , 1 -# CHECK: module , 1 +# CHECK: builtin.func , 1 +# CHECK: builtin.module , 1 # CHECK: std.return , 1 run(testRunPipeline) diff --git a/mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp b/mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp --- a/mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp +++ b/mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp @@ -726,9 +726,6 @@ os << llvm::formatv(fileHeader, clDialectName.getValue()); os << llvm::formatv(dialectClassTemplate, clDialectName.getValue()); - if (clDialectName == "builtin") - clDialectName = ""; - for (const llvm::Record *rec : records.getAllDerivedDefinitions("Op")) { Operator op(rec); if (op.getDialectName() == clDialectName.getValue()) diff --git a/mlir/unittests/IR/InterfaceAttachmentTest.cpp b/mlir/unittests/IR/InterfaceAttachmentTest.cpp --- a/mlir/unittests/IR/InterfaceAttachmentTest.cpp +++ b/mlir/unittests/IR/InterfaceAttachmentTest.cpp @@ -298,10 +298,10 @@ ModuleOp::attachInterface(context); auto iface = dyn_cast(moduleOp.getOperation()); ASSERT_TRUE(iface != nullptr); - EXPECT_EQ(iface.getNameLengthPlusArg(10), 16u); - EXPECT_EQ(iface.getNameLengthTimesArg(3), 18u); - EXPECT_EQ(iface.getNameLengthPlusArgTwice(18), 42u); - EXPECT_EQ(iface.getNameLengthMinusArg(5), 1u); + EXPECT_EQ(iface.getNameLengthPlusArg(10), 24u); + EXPECT_EQ(iface.getNameLengthTimesArg(3), 42u); + EXPECT_EQ(iface.getNameLengthPlusArgTwice(18), 50u); + EXPECT_EQ(iface.getNameLengthMinusArg(5), 9u); // Default implementation can be overridden. auto funcOp = FuncOp::create(UnknownLoc::get(&context), "function", @@ -310,9 +310,9 @@ FuncOp::attachInterface(context); iface = dyn_cast(funcOp.getOperation()); ASSERT_TRUE(iface != nullptr); - EXPECT_EQ(iface.getNameLengthPlusArg(10), 14u); + EXPECT_EQ(iface.getNameLengthPlusArg(10), 22u); EXPECT_EQ(iface.getNameLengthTimesArg(0), 42u); - EXPECT_EQ(iface.getNameLengthPlusArgTwice(8), 20u); + EXPECT_EQ(iface.getNameLengthPlusArgTwice(8), 28u); EXPECT_EQ(iface.getNameLengthMinusArg(1000), 21u); // Another context doesn't have the interfaces registered.