Fix the detection of boolean splat values in DenseElementsAttr for arrays with <=15 values.

PiperOrigin-RevId: 253711372

Add a TableGen Type predicate to check that an operand type can be broadcasted to a particular output type

PiperOrigin-RevId: 253694397

Refactor generic op printing: extract a public printFunctionalType() on OpAsmPrinter (NFC)

PiperOrigin-RevId: 253674584

[spirv] Add spv.constant

This CL defines a single `spv.constant` op to represent various
flavors of SPIR-V constant instructions.

PiperOrigin-RevId: 253665716

[spirv] Define common types using op definition spec

This CL also tightens spv.FMul to only accept 16/32/64-bit floats.

PiperOrigin-RevId: 253649352

Verification for gpu.launch_func should rely on function type and not on the
actual body of a kernel function. This enables using gpu.launch_func with
external kernel declarations.

PiperOrigin-RevId: 253639770

Also consider attributes when getting context for Operation

This CL also updates to use containing region as a fallback way to find
context since functions will eventually become ops with regions.

PiperOrigin-RevId: 253627322

[spirv] Add doc regarding the SPIR-V dialect

* Add basic design philosophy
* Add type syntax to both the doc and type parser comments

PiperOrigin-RevId: 253625782

Introduce std.index_cast and its lowering+translation to LLVM

Index types integers of platform-specific bit width.  They are used to index
memrefs and as loop induction variables, however they could not be obtained
from an integer until now, making it virtually impossible to express indirect
accesses (given that memrefs of indices are not allowed) or data-dependent
loops.  Introduce `std.index_cast` to transform indices into integers and vice
versa.  The semantics of this cast is to sign-extend when casting to a wider
integer, and to truncate when casting to a narrower integer.  It belongs to
StandardOps because both types it operates on are standard types, and because
its results are likely to be used in std.load and std.store.

Introduce llvm.sext, llvm.zext and llvm.trunc operations to the LLVM dialect.
Provide the conversion of `std.index_cast` to llvm.sext or llvm.trunc,
depending on the actual bitwidth of `index` known during the conversion.

PiperOrigin-RevId: 253624100

Factor Region::getUsedValuesDefinedAbove into Transforms/RegionUtils

Arguably, this function is only useful for transformations and should not
pollute the main IR.  Also make sure it accepts a the resulting container
by-reference instead of returning it.

PiperOrigin-RevId: 253622981

LoopFusion: adds support for computing forward computation slices, which will enable fusion of consumer loop nests into their producers in subsequent CLs.

PiperOrigin-RevId: 253601994

Add lowering pass from GPU dialect operations to LLVM/NVVM intrinsics.

PiperOrigin-RevId: 253551452

Move the Region type out to its own .h/.cpp file instead of putting it into
Block.h/cpp.

This doesn't change much but makes it easier to find.

PiperOrigin-RevId: 253423041

Use braces when building an 'llvm_return' via EDSC intrinsics. This fixes a build error on MSVC where it is unable to properly handled template type aliases.

PiperOrigin-RevId: 253339204

Remove dead code.

PiperOrigin-RevId: 253314416

Start moving conversions to {lib,include/mlir}/Conversion

Conversions from dialect A to dialect B depend on both A and B.  Therefore, it
is reasonable for them to live in a separate library that depends on both
DialectA and DialectB library, and does not forces dependees of DialectA or
DialectB to also link in the conversion.  Create the directory layout for the
conversions and move the Standard to LLVM dialect conversion as the first
example.

PiperOrigin-RevId: 253312252

Disallow using NOperands/NResults when N < 2. We have special traits for the case of 0/1 that we explicitly check for throughout the codebase. This also fixes weird build failures in MSVC where it doesn't properly handle template type aliases.

PiperOrigin-RevId: 253269936

Add Linalg CopyOp

This CL adds a generic CopyOp to Linalg and its lowering to loops.
The CopyOp supports input and output permutation maps.
When combined with tiling and allocating a new local buffer, this should provide basic support for implementing simple memory transfers with coalescing.

At the moment, lowering copies to a library call is not supported.

PiperOrigin-RevId: 253250497

Add an overloaded 'get' method to DenseElementsAttr that accepts an initializer_list.

PiperOrigin-RevId: 253234385

Explicitly construct ArrayRef in AttributeTest.cpp

Some compilers find initializer list constructors from boolean literals
ambiguous between ArrayRef<bool> and ArrayRef<Attribute>.  Call the
ArrayRef<bool> constructor explicitly to disambiguate.

PiperOrigin-RevId: 253224859

Convert a nest affine loops to a GPU kernel

This converts entire loops into threads/blocks.  No check on the size of the
block or grid, or on the validity of parallelization is performed, it is under
the responsibility of the caller to strip-mine the loops and to perform the
dependence analysis before calling the conversion.

PiperOrigin-RevId: 253189268

Refactor SplatElementsAttr to inherit from DenseElementsAttr as opposed to being a separate Attribute type. DenseElementsAttr provides a better internal representation for splat values as well as better API for accessing elements.

PiperOrigin-RevId: 253138287

NFC: Fix a narrowing conversion from size_t to int64_t when constructing a VectorType.

PiperOrigin-RevId: 253125435

NFC: Fix a warning for casting away const qualifiers.

PiperOrigin-RevId: 253124057

Add ability to verify type matching between operands/results

This extends and generalizes the functionality for checking that element types match

PiperOrigin-RevId: 253110512

Add a definition of the library function to use when Linalg ops are
lowered to LLVM, instead of expecting one to exist in the Module

PiperOrigin-RevId: 253097382

Add several utility 'getValues<T>' functions to DenseElementsAttr that return ranges as opposed to filling a SmallVector. This is much more efficient for the general case and allows for avoiding constructing APInt/APFloat/Attribute when possible.

PiperOrigin-RevId: 253092550

Disallow non-index operands and results in affine.apply

`affine.apply` is supposed to operate on values of index types in context of
affine loops.  It is possible to programmatically constuct an `affine.apply`
that takes values of other types as operands or returns them, but it would not
be parseable.  Disallow such cases in the verifier.

PiperOrigin-RevId: 253021704

GPU Dialect: introduce gpu.return

This terminator operation should appear at the end of the blocks in the body
region of `gpu.launch` when the control flow needs to be returned from the
kernel.  Using `std.return` in this place is ambiguous: it may exit the body
region or the enclosing function.  Furthermore, this allows the GPU dialect to
impose the absence of return values as required by the underlying kernel
execution models.

Update outlining transformation from `gpu.launch` to `gpu.launch_func` so that
it replaces `gpu.return` with `std.return`.

PiperOrigin-RevId: 252985992

[spirv] Add SPV_StorageClassAttr and PointerType

Pointer types need to specify the storage class. We use the utility functions
generated from SPV_StorageClassAttr to parse and print the storage classes.

Also improved the case that no element type is provided for (runtime) array.

PiperOrigin-RevId: 252935599

Update the Parser to support parsing/printing DenseElementAttrs with a splat value. The syntax for this is the same as 0-D tensors:

  dense<tensor<100x100x100xi32>, 10>
  dense<tensor<1x1x1xi64>, -5>

PiperOrigin-RevId: 252907880

[spirv] Use mlir::parseType in type parsers and add more checks

PiperOrigin-RevId: 252874386

[ODG] Fix value indices in verification error messages

we should use the dynamic index for the specific value instead
of the static one for ODS-declared values.

PiperOrigin-RevId: 252873052

Add Linalg FillOp

This CL adds a generic FillOp to Linalg and its lowering to loops.
This is achieved by avoiding to specify the static NLoopTypes and ViewRanks type traits but instead defines the relevant methods as `extraClassDeclaration`.
The relevant AffineMap and scalar emission code are added, with relevant tests.

This gives us a first rank-agnostic Linalg op with its generic lowering to loops that should compose with view-based tiling and fusion.

PiperOrigin-RevId: 252869205

Fix static assertion in AttributeDetail.h

llvm::maskTrailingOnes<char> runs into a static assertion on the type not being
unsigned.  Use `unsigned char` instead of `char`.
PiperOrigin-RevId: 252827214

Update 2 instances of isa<BlockArgument>

PiperOrigin-RevId: 252739405

Fix OSS build

Missing a spot with std::make_pair causes a compiler error in OSS.
Also fixes the warning:
```
warning: suggest parentheses around ‘&&’ within ‘||’ [-Wparentheses]
            it->getSecond()->getType().isa<BufferType>() &&
            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~
                "Buffer or block argument expected");
```
PiperOrigin-RevId: 252738323

Refactor DenseElementsAttr to support auto-splatting the dense data on construction. This essentially means that we always auto-detect splat data and only store the minimum amount of data necessary. Support for parsing dense splats, and removing SplatElementsAttr(now that it is redundant) will come in followup cls

PiperOrigin-RevId: 252720561

Add basic cost modeling to the dialect conversion infrastructure. This initial cost model favors specific patterns based upon two criteria:
1) Lowest minimum pattern stack depth when legalizing.
  - This leads the system to favor patterns that have lower legalization stacks, i.e. represent a more direct mapping to the target.

2)  Pattern benefit.
  - When considering multiple patterns with the same legalization depth, this favors patterns with a larger specified benefit.

PiperOrigin-RevId: 252713470

Add a Linalg fusion pass.

This CL adds a fusion pass for the Linalg dialect.
Fusion is backed by a simple analysis on SSA values and proceeds as follows:
1. A dependence and alias analyses are performed on views.
2. A Linalg op is tiled by a particular tile size. This creates a new Linalg op operating on tiled loops and tiled views.
3. The dependence analysis is used to obtain ops that produce views that are consumed by the original Linalg op.
4. Dependence analysis is used to determine whether op-level fusion would violate any dependence.
5. If fusion is safe, matching tiled views are sliced for the producing op.
6. A tiled clone of the producer op is written before the tiled consumer op.

If a producer is fused, its entire output view has been computed in tiled form.
The original producer op is then erased.

PiperOrigin-RevId: 252695194

Add a lowering for Linalg matmul to LLVM

This CL adds a lowering to LLVM for MamulOp and a corresponding integration test.

View descriptor manipulation is moved from MLIR's LLVM dialect to C++ code compiled on the side. To this end a separation is introduced between `cblas.cpp` and `cblas_interface.cpp`, the latter operating on view types whose ABI correspond to the LLVM signature generated by MLIR.

An intermediary step is introduced that allocates a new descriptor on the MLIR side for the purpose of passing it to LLVM. The reason for this extra step is that the ABI for by-value ViewType objects wants aligned descriptors, e.g.:
```
extern "C" void linalg_dot_impl(ViewType<float, 1> X, ViewType<float, 1> Y,
                                BaseViewType<float> Z) {
   ...
}
```
produces LLVM IR with the signature:
```
%struct.ViewType = type { %struct.BaseViewType, [1 x i64], [1 x i64] }
%struct.BaseViewType = type { float*, i64 }

define void @linalg_dot_impl(%struct.ViewType* byval align 8, %struct.ViewType* byval align 8, float*, i64) tensorflow/mlir#0 {
...
}
```

We don't seem to be able to make such aligned  allocations in the MLIR -> LLVM converter atm.
Going through a level of indirection allows the test to pass.
The temporary tradeoff is that the MLIR shims have to be written by hand.
They will disappear in the future.

PiperOrigin-RevId: 252670672

Simplify trait naming for verifying argument/result constraints.

Improve the naming to something more intuitive.

PiperOrigin-RevId: 252662347

[spirv] Add a skeleton to translate standard ops into SPIR-V dialect

PiperOrigin-RevId: 252651994

Add a utility to OpAsmPrinter for printing an optional trailing arrow type list. This is useful for any operation that wants to print a set of types in the same format as a FunctionType/Operation signature.

PiperOrigin-RevId: 252647152

NFC: Cleanup the naming scheme for registering legalization actions to be consistent, and move a file functions to the source file.

PiperOrigin-RevId: 252639629

Use DialectConversion to lower the Affine dialect to the Standard dialect

This introduces the support for region-containing operations to the dialect
conversion framework in order to support the conversion of affine control-flow
operations into the standard control flow with branches.  Regions that belong
to an operation are converted before the operation itself.  The
DialectConversionPattern can therefore access the converted regions of the
original operation and process them further if necessary.  In particular, the
conversion is allowed to move the blocks from the original region to other
regions and to split blocks into multiple blocks.  All block manipulations must
be performed through the PatternRewriter to ensure they will be undone if the
conversion fails.

Port the pass converting from the affine dialect (loops and ifs with bodies as
regions) to the standard dialect (branch-based cfg) to use DialectConversion in
order to exercise this new functionality.  The modification to the lowering
functions are minor and are focused on using the PatterRewriter instead of
directly modifying the IR.

PiperOrigin-RevId: 252625169

[spirv] Include SPIRVStructureOps.td in SPIRVOps.td

This allows us to have SPIRVOps.td as the single entry point for
all SPIR-V ops, which simplifies downstream users and build rules.

PiperOrigin-RevId: 252609258

[ODG] Add support for private methods in class writers

PiperOrigin-RevId: 252602093

[spirv] Add missing CMake rules for enum utility generation

PiperOrigin-RevId: 252601308

Add bool constant attributes.

PiperOrigin-RevId: 252551030

Fix MSVC 2019 missing <string> include (NFC)

Fix tensorflow/mlir#31.

PiperOrigin-RevId: 252547010

Change a call to FloatAttr::getChecked to FloatAttr::get inside of 'parseFloatAttr'. The invariants of FloatAttr are already checked before construction. This also removes an unnecessary materialization of a mlir::Location which becomes expensive when parsing dense element literals.

PiperOrigin-RevId: 252545776

Add a general Operation::verify that verifies an operation instance and the dominance of operations in any nested regions.

PiperOrigin-RevId: 252529850

[spirv] Add values for enum cases and generate the enum utilities

PiperOrigin-RevId: 252494957

[spirv] NFC: use two spaces for indentation in gen_spirv_dialect.py

PiperOrigin-RevId: 252469663

Expose a minimal type parser to dialects.

This CL exposes a parseType method which allows standalone reuse of the MLIR type parsing mechanism. This is a free function for now because the underlying MLIR parser is not guaranteed to receive a StringRef which lives in the proper MemBuffer. This requires building a new MemBuffer/SourceMgr and modifying the Parser constructor to not require an mlir::Module.

The error diagnostic emitted by parseType has context limited to the local string.
For now the dialect has the additional option to emit its own extra error that has the FileLineColLoc context.

In the future, both error messages should be combined into a single error.

PiperOrigin-RevId: 252468911

[spirv] Add array and run-time array types

PiperOrigin-RevId: 252458108

[ODG] Address compiler warnings of comparing signed and unsigned integer expressions

PiperOrigin-RevId: 252442613

Return dependence result enum to distiguish between dependence result and error cases (NFC).

PiperOrigin-RevId: 252437616

[ODS] Support variadic operand/result verification

This CL enables verification code generation for variadic operands and results.
In verify(), we use fallback getter methods to access all the dynamic values
belonging to one static variadic operand/result to reuse the value range
calculation there.

PiperOrigin-RevId: 252288219

[ODG] Use getODSOperands() and getODSResults() to back accessors

This CL added getODSOperands() and getODSResults() as fallback getter methods for
getting all the dynamic values corresponding to a static operand/result (which
can be variadic). It should provide a uniform way of calculating the value ranges.
All named getter methods are layered on top of these methods now.

PiperOrigin-RevId: 252284270

[TableGen] Generating enum definitions and utility functions

Enum attributes can be defined using `EnumAttr`, which requires all its cases
to be defined with `EnumAttrCase`. To facilitate the interaction between
`EnumAttr`s and their C++ consumers, add a new EnumsGen TableGen backend
to generate a few common utilities, including an enum class, `llvm::DenseMapInfo`
for the enum class, conversion functions from/to strings.

This is controlled via the `-gen-enum-decls` and `-gen-enum-defs` command-line
options of `mlir-tblgen`.

PiperOrigin-RevId: 252209623

Update function comment, since we added FP16 support for getZeroAttr.

PiperOrigin-RevId: 252110998

NFC: Cleanup the grouping of DenseElementsAttr 'get' methods, and move the bit write/read functions to static functions in Attributes.cpp.

PiperOrigin-RevId: 252094145

Remove the ability to directly construct a DenseElementsAttr with a raw character buffer. This made assumptions about how DenseElementsAttr structured its internal storage, which may change in the future. To replace the existing use cases, a few utility methods have been added:

* 'get' methods that allow constructing from an ArrayRef of integer or floating point values.
* A 'reshape' method to allow for changing the shape without changing the underlying data.

PiperOrigin-RevId: 252067898

NFC: Cleanup FuncVerifier and refactor it into a general OperationVerifier. The function specific verification has been moved into Function::verify. This is in preparation for adding a general Operation::verify method.

PiperOrigin-RevId: 252065646

Remove unnecessary StandardOps dependency

PiperOrigin-RevId: 252032386

Add a convenient getDialect() accessor on Op<> class

PiperOrigin-RevId: 251988464

NFC: Replace typelist_contains with llvm::is_one_of. This should also fix weird build failures on MSVC related to typelist_contains for missing template arguments.

PiperOrigin-RevId: 251987621

Add free standing getElementTypeOrSelf member.

This function returns the element type of the underlying type or the input type itself. This removes some of the casting and code from ODS and into C++ code.

I've not converted all the call sites (as this requires a new include and target) and wanted to run it past folks first.

PiperOrigin-RevId: 251978156

Internal change

PiperOrigin-RevId: 251972430

Add the getDialectNamespace static utility method to the Linalg dialect.

PiperOrigin-RevId: 251953766

Remove the explicit attribute kinds for DenseIntElementsAttr and DenseFPElementsAttr in favor of just one DenseElementsAttr. Now that attribute has the ability to define 'classof(Attribute attr)' methods, these derived classes can just be specializations of the main attribute class.

PiperOrigin-RevId: 251948820

Adding utility to parse optional colon-type-lists.

PiperOrigin-RevId: 251945512

Simplify DenseElementsAttr by rounding up the storage of odd bit widths to 8-bits. This removes the requirement that the underlying buffer be aligned to 64 bits which opens the door for several optimizations in the future, e.g. detecting splat.

PiperOrigin-RevId: 251944922

Add support to ConversionTarget for storing legalization actions for entire dialects as opposed to individual operations. This allows for better support of unregistered operations, as well as removing the need to collect all of the operations for a given dialect(which may be very expensive).

PiperOrigin-RevId: 251943590

Add support for matchAndRewrite to the DialectConversion patterns. This also drops the default "always succeed" match override to better align with RewritePattern.

PiperOrigin-RevId: 251941625

Add a general operation property 'IsolatedFromAbove' that guarantees that all regions of a given operation are explicit capture only and will not reference values defined above the enclosing operation. This trait will be useful for applying some of the properties currently attached to Functions to operations, e.g. verifying dominance within a specific operation, enabling multi-threading of certain transformations between different instances, etc.

PiperOrigin-RevId: 251927466

Support constructing DominanceInfo with an Operation. This computes the dominance information for any nested regions within the operation.

PiperOrigin-RevId: 251896520

Support FP16 in getZeroAttr.

PiperOrigin-RevId: 251783931

Add a verify method to FuncOp and check that the type signature matches the signature of the entry block.

PiperOrigin-RevId: 251759848

NFC: Rename FunctionParser to OperationParser. There is nothing specific to functions about this parser and provides general parser support for operations, and regions of operations.

PiperOrigin-RevId: 251749622

Minor change to Linalg Tablegen file to not include OpBase.td if already included by another include

PiperOrigin-RevId: 251725376

NFC: Cleanup the definitions of OpAsmParser and CustomOpAsmParser by adding comments, grouping similar functionality, and adding header blocks.

PiperOrigin-RevId: 251723883

Add utility 'create' methods to OperationFolder that will create an operation with a given OpBuilder and automatically try to fold it, similarly to OpBuilder::createOrFold. The difference here is that these methods enable folding to constants in addition to existing values. This functionality is then used to replace linalg::FunctionConstants.

PiperOrigin-RevId: 251716247

NFC: Rename FunctionParser::builder to opBuilder. This allows for removing the clang specific pragmas for ignoring field shadowing warnings.

PiperOrigin-RevId: 251712823

Fix a warning for missing parentheses around '||' inside of an assert.

PiperOrigin-RevId: 251712106

NFC: Cleanup FunctionParser by removing dead methods, adding header blocks, and grouping related pieces of functionality.

PiperOrigin-RevId: 251688578

Fix a typo in error message.

PiperOrigin-RevId: 251681475

Add new 'createOrFold' methods to FuncBuilder to immediately try to fold an operation after creating it. This can be used to remove operations that are likely to be trivially folded later. Note, these functions only fold operations if all of the folded results are existing values.

PiperOrigin-RevId: 251674299

Always remap results when replacing an operation. This prevents a crash when lowering identity(passthrough) operations to the same resultant type as the original operation.

PiperOrigin-RevId: 251665492

When cleaning up after a failed legalization pattern, make sure to remove any newly created value mappings.

PiperOrigin-RevId: 251658984

Add a few utility overloads for OpAsmParser methods:
* Add a getCurrentLocation that returns the location directly.
* Add parseOperandList/parseTrailingOperandList overloads without the required operand count.

PiperOrigin-RevId: 251585488

ODG: Always deference operand/result when using named arg/result.

Considered adding more placeholders to designate types in the replacement pattern, but convinced for now sticking to simpler approach. This should at least enable specifying constraints across operands/results/attributes and we can start getting rid of the special cases.

PiperOrigin-RevId: 251564893

NFC: Rename FuncBuilder to OpBuilder and refactor to take a top level region instead of a function.

PiperOrigin-RevId: 251563898

Add support to AffineApplyOp::fold for folding dim and symbol expression results.

PiperOrigin-RevId: 251512700

[spirv] Basic validity of SPV_ModuleOp

This CL adds SPV_ModuleEndOp for terminating the only block inside a
SPV_ModuleOp's only region. Verification now enforces a spv.module only
contains func or spv.* ops and no external or nested functions are
present. Because of the structural requirement of a block, spv.Return
is also added in this CL.

PiperOrigin-RevId: 251510706

Add a utility function to Op that allows for checking if an operation has a specific trait.

PiperOrigin-RevId: 251489498

NFC: Rename FoldHelper to OperationFolder and split a large function in two.

PiperOrigin-RevId: 251485843

Adding additional dialect parsing utilities, conversion wrappers, and traversal helpers.
- added a typed walk to Block (matching the equivalent on Function)
- added token parsers (incl optional variants) for : and (
- added applyConversionPatterns that takes a list of functions to apply patterns to

PiperOrigin-RevId: 251481608