Decouple running a conversion from the DialectConversion class. The DialectConversion class is only necessary for type signature changes(block arguments or function arguments). This isn't always desired when performing a dialect conversion. This allows for those conversions without this need to run per function instead of per module.

--

PiperOrigin-RevId: 249657549

Fix Linalg lowering to loops

    This CL makes lowering to loops always be a:
    ```
    %D = linalg.dim %view, constant : !linalg.view<...>
    affine.for %ix = %c0 to %D {
      ...
    }
    ```

    This form composes correctly with tiling and is also the proper way to emit loops from views that across function boundaries.
    The previous version that would extract the range_min/max/step was composing incorrectly with tiling (i.e. would shift by range_min both in the loop bounds and in the slice) and would not work across function boundaries.

    The relevant tests are updated and a new test `dot_view`---which lowers to loops from views passed as function parameters---is added.

    When additional context is available, the linalg.dim operations should be folded away but this is left for a future CL.

--

PiperOrigin-RevId: 249634712

Automated rollback of changelist 247713812.

PiperOrigin-RevId: 249605627

Add LLVM::IntToPtrOp and LLVM::PtrToIntOp to LLVM dialect.

--

PiperOrigin-RevId: 249604199

Automated rollback of changelist 249538085.

PiperOrigin-RevId: 249550805

Added the ability to run a mapping function across the values of an elements
    attr. This supports both the SplatElementsAttr and DenseElementsAttr for both
    float and integer inputs / outputs.

--

PiperOrigin-RevId: 249538085

Add thread-safe utilities to LLVMType to allow constructing llvm types in a multi-threaded environment. The LLVMContext is not thread-safe and directly constructing a raw llvm::Type can create situations where the LLVMContext is modified by multiple threads at the same time.

--

PiperOrigin-RevId: 249526233

Refactor FunctionAttr to hold the internal function reference by name instead of pointer. The one downside to this is that the function reference held by a FunctionAttr needs to be explicitly looked up from the parent module. This provides several benefits though:
    * There is no longer a need to explicitly remap function attrs.
      - This removes a potentially expensive call from the destructor of Function.
      - This will enable some interprocedural transformations to now run intraprocedurally.
      - This wasn't scalable and forces dialect defined attributes to override
        a virtual function.
    * Replacing a function is now a trivial operation.
    * This is a necessary first step to representing functions as operations.

--

PiperOrigin-RevId: 249510802

Return nullptr on Region::getContainingOperation()/getContainingFunction() instead of asserting

    This avoids crashing when trying to dump an operation nested in a region that isn't yet attached to an operation, which is quite useful when debugging.

    This alone won't be enough to print an unlink Operation, it'll display `<<UNLINKED INSTRUCTION>>`.

--

PiperOrigin-RevId: 249496388

Make EDSC builder test more robust to the order of evaluation

    EDSC builder test uses FileCheck to match the IR produced by EDSC in the
    textual order.  For mathematical operations, EDSC relies on overloaded
    operators.  Since they are essentially function calls, the order of evaluation
    of their operands is unspecified and differs between compilers.  Do not rely on
    a specific order of operands and just check they are all emitted before the
    last operation.  Give names to matched SSA values in order to make sure the
    right operands are used in relevant places.

--

PiperOrigin-RevId: 249494995

Refactor DialectConversion to operate on functions in-place *without* any cloning. This works by caching all of the requested pattern rewrite operations, e.g. replace operation, and only applying them on a completely successful conversion.

--

PiperOrigin-RevId: 249490306

Update Attribute::getDialect/Type::getDialect to return a non-const dialect reference.

--

PiperOrigin-RevId: 249467245

NFC: Fix the name of a comment header block in Diagnostics.cpp.

--

PiperOrigin-RevId: 249466645

Add a new interleaveComma that allows specifying a unary function for the container elements.

--

PiperOrigin-RevId: 249349269

Make static shape tensor container match other container types

    Suffix with Of and take a list of types. Also give a better description that includes the element type information.

--

PiperOrigin-RevId: 249341159

Simplify container type definitions

    The passed element type description is usually unnecessary, and it's just as valid to want to pass a description for the entire container. In either case there's an alternative (Separate element type def or a TypeAlias) and we don't need to pollute the main API.

    To allow for this, I cleaned up the TF op definitions and added some additional utilities.

--

PiperOrigin-RevId: 249340979

Make the ParallelDiagnosticHandler used by the pass manager publicly available in Diagnostics.h. This provides a common utility for deterministically handling diagnostics in a multi-threaded environment.

--

PiperOrigin-RevId: 249325937

Fix a bug in toy LateLowering where a type conversion was using 'cast' instead of 'dyn_cast'.

--

PiperOrigin-RevId: 249325111

Clean up container type names in OpBase

    Establish the following convention:
    1. Container class types end in "Of" (e.g. TensorOf) and take a list of allowed types.
    2. An X container where only a single type is allowed is called TypeX (e.g. I32Tensor).
    3. An X container where any type is allowed is called AnyX (e.g. AnyTensor).

--

PiperOrigin-RevId: 249281018

CMake build: force-link SDBM lib into SDBM unit tests

    Otherwise, GCC < 7 does not link in the dialect registration, fails to look up
    the dialect in the context and cannot construct SDBM objects.

--

PiperOrigin-RevId: 249259758

Move SDBM uniquer into the SDBM dialect

    MLIRContext does not have to be aware of the SDBM unique data structures
    directly.  Move the SDBM storage uniquer from MLIRContext to the SDBM dialect
    instance.  Expressions that previously required a context to be constructed now
    require an instance of the dialect in order to access the uniquer.  While they
    could look up the dialect in the context, it would have introduced a rather
    expensive lookup into each construction.  Instead, the caller is expected to
    obtain the dialect instance and cache it.

--

PiperOrigin-RevId: 249245199

Move SDBM infrastructure into a new SDBM dialect

    We now have sufficient extensibility in dialects to move attribute components
    such as SDBM out of the core IR into a dedicated dialect and make them
    optional.  Introduce an SDBM dialect and move the code.  This is a mostly
    non-functional change.

--

PiperOrigin-RevId: 249244802

SDBMExpr: factor uniqu'ing out of MLIRContext.cpp

    SDBM expressions are designed as components of an attribute, similarly to
    affine expressions.  As such, they need to be unique'd in the MLIRContext.
    When SDBM expressions were implemented, uniqu'ing objects in a context required
    to modify MLIRContext implementation.  This is no longer the case as generic
    StorageUniquer has been introduced.  Port the SDBMExpr uniqu'ing to use a newly
    introduced uniquer and remove SDBM construction from MLIRContext.cpp.

--

PiperOrigin-RevId: 249244739

Fix -Wsign-compare in OperationSupportTest.cpp

    A couple of warnings was produced when compiling this test due to comaprisons
    with a signed literal.  Used unsigned literals instead.

--

PiperOrigin-RevId: 249242970

Linalg: avoid deriving from MultiOperandTraitBase multiple times

    The Op Definition Generator will automatically insert the VariadicOperands
    trait if an op has variadic operands or results. It already derives from
    MultiOperandTraitBase.

--

PiperOrigin-RevId: 249227268

Small cleanup.
    * Use `cast` rather than `dyn_cast` to get an assertion failure rather than a segfault in case of a type mismatch.
    * Use stream operators to `emitOpError`s.

--

PiperOrigin-RevId: 249208135

AffineExpr: factor uniqu'ing out of MLIRContext.cpp

    Affine expressions are designed as components of an attribute and are unique'd
    in the MLIRContext.  When affine expressions were implemented, uniqu'ing
    objects in a context required to modify MLIRContext implementation.  This is no
    longer the case as generic StorageUniquer has been introduced.  Port the
    AffineExpr construction to use the new infrastructure by introducing an
    affineUniquer into the MLIRContext.

--

PiperOrigin-RevId: 249207539

Drop AffineExpr::Null

    Similarly to other value-type wrappers, the default constructor of AffineExpr
    constructs a null object and removes the need for an explicit ::Null
    constructor.  Drop it and remove the only user which can trivially rely on the
    default constructor.

--

PiperOrigin-RevId: 249207502

Change getParent() to be a const function. This is only necessary because ilist_node_with_parent specifically requires a 'getParent() const' method. If/When ilist_node removes this constraint we should drop the const to fit the rest of the MLIR const model.

--

PiperOrigin-RevId: 249193257

Upstream the Quantizer tool (part 4).

    This adds the basic passes needed and ties them into mlir-opt. Also adds two specific unit tests that exercise them.

    Next step is a standalone quantizer tool and additional cleanup.
    Tested:
      ninja check-mlir

--

PiperOrigin-RevId: 249167690

When changing the type of a Function, also update the type of the respective FunctionAttr.

--

PiperOrigin-RevId: 249137558

[LoopFusion] Don't count terminator op in compute cost.

--

PiperOrigin-RevId: 249124895

Use lambdas for nesting edsc constructs.

    Using ArrayRef introduces issues with the order of evaluation between a constructor and
    the arguments of the subsequent calls to the `operator()`.
    As a consequence the order of captures is not well-defined can go wrong with certain compilers (e.g. gcc-6.4).
    This CL fixes the issue by using lambdas in lieu of ArrayRef.

--

PiperOrigin-RevId: 249114775

Fix MacOS test: use %shlibext in lit command line to expand to .dylib on MacOS and .so on Linux

--

PiperOrigin-RevId: 249113478

Define a string join tablegen utility

--

PiperOrigin-RevId: 249083600

Add CMakeLists.txt entry for Linalg/Transforms/LowerToLoops

--

PiperOrigin-RevId: 249080647

Fix automatic description for AnyTypeOf

    Unfortunately, this now gives a segfault if you pass it an empty list, similar to stringify. Given how fiddly this is, we should probably have a string join helper. I'll fix both of these using better tablegen helpers in a follow-up.

--

PiperOrigin-RevId: 249076849

Rename "AnyOf" and "AllOf" combined predicates to "Or" and "And", respectively.

    This reduces conflict between these and other type names, where we're moving towards "Of" indicating a container type containing certain types. It also better matches the "Neg" predicate modifier and generally is pretty understandable/readable for predicates.

--

PiperOrigin-RevId: 249076508

Delete IntegerBase and FloatBase tablegen classes

    These don't have any behavior and just delegate to Type. The only references are in OpBase.td Since the tablegen type hierarchy is not realized in the generated C++ these also aren't providing value for examining the type hierarchy

--

PiperOrigin-RevId: 249073939

[ODS] Allow dialect to specify C++ namespaces

    Previously we force the C++ namespaces to be `NS` if `SomeOp` is defined as
    `NS_SomeOp`. This is too rigid as it does not support nested namespaces
    well. This CL adds a "namespace" field into the Dialect class to allow
    flexible namespaces.

--

PiperOrigin-RevId: 249064981

Fix Linalg/llvm_ir test

--

PiperOrigin-RevId: 249057043

Fix stride computation bug when lowering linalg.view to llvm

--

PiperOrigin-RevId: 249053115

Add lowering of LinalgLibraryOps to linalg.load + linalg.store.

    This CL adds a pass to lower out of dot,matvec,matmul etc and into a combination of affine.for, linalg.load and linalg.store operations.
    Such operations can then later lowered to LLVM.
    This CL essentially performs op expansion using EDSCs and factors out a few common utils from Tiling.cpp.

--

PiperOrigin-RevId: 249049518

Use FileCheck to test SDBM

    SDBM has an output format representing the unterlying matrix and stripe
    expressions.  Move the SDBM tests from unit testing framework to
    FileCheck-based tests, printing them to the standard output and using FileCheck
    to test the output.  Tests that check the API proper (e.g. that SDBM
    expressions have a specific subtype) and that rely on non-syntatic properties
    (equality of the set of constraints) are not ported.

--

PiperOrigin-RevId: 249006055

ExecutionEngine: drop PassManager integration

    Originally, ExecutionEngine was created before MLIR had a proper pass
    management infrastructure or an LLVM IR dialect (using the LLVM target
    directly).  It has been running a bunch of lowering passes to convert the input
    IR from Standard+Affine dialects to LLVM IR and, later, to the LLVM IR dialect.
    This is no longer necessary and is even undesirable for compilation flows that
    perform their own conversion to the LLVM IR dialect.  Drop this integration and
    make ExecutionEngine accept only the LLVM IR dialect.  Users of the
    ExecutionEngine can call the relevant passes themselves.

--

PiperOrigin-RevId: 249004676

Fix debug build: static constexpr data member must have a definition (until C++17)

--

PiperOrigin-RevId: 248990338

Add support for streaming an OperationName into a Diagnostic.

--

PiperOrigin-RevId: 248987646

NFC: Tidy up DialectConversion.cpp and rename DialectOpConversion to  DialectConversionPattern.

--

PiperOrigin-RevId: 248980810

Refactor the DialectConversion process to clone each function and then operate in-place, as opposed to incrementally constructing a new function. This is crucial to allowing the use of non type-conversion patterns(normal RewritePatterns) as part of the conversion process.

    The converter now works by inserting fake producer operations when replacing the results of an existing operation with values of a different, now legal, type. These fake operations are guaranteed to never escape the converter.

--

PiperOrigin-RevId: 248969130

Allow a function to take the name of another existing function.

--

PiperOrigin-RevId: 248968285

Add support for streaming Operations into Diagnostics.

--

PiperOrigin-RevId: 248967563

Update the rewrite methods of each of the DialectConversion patterns to notify the PatternRewriter that the operation is being replaced.

--

PiperOrigin-RevId: 248965082

Add a utility function 'Operation::replaceUsesOfWith' to replace uses of a value within a single operation.

--

PiperOrigin-RevId: 248961779

Move the ConversionListBuilder utility to PatternMatch.h and rename it to RewriteListBuilder. It has no specific functionality for DialectOpConversion patterns and can be useful for RewritePatterns in general.

--

PiperOrigin-RevId: 248884466

Add user iterators to IRObjects, i.e. Values.

--

PiperOrigin-RevId: 248877752

Make shape matching work for any shaped type.

    The current implementation makes some assumptions about what can be a shaped type, which aren't really necessary. It also has strange behavior for types that aren't in the limited set it handles (e.g. dialect-defined types)

    Updated the comment to match the implementation.

    This is partially motivated by the desire to make MemRef a subclass of ShapedType

--

PiperOrigin-RevId: 248859674

Rewrite the DialectOpConversion patterns to inherit from RewritePattern instead of Pattern. This simplifies the infrastructure a bit by being able to reuse PatternRewriter and the RewritePatternMatcher, but also starts to lay the groundwork for a more generalized legalization framework that can operate on DialectOpConversions as well as normal RewritePatterns.

--

PiperOrigin-RevId: 248836492

Clean up tablegen vector and tensor types

    There was a weird mix of names, styles, and inheritance here. I think this makes it cleaner and more consistent. We can also have a more principled and far-reaching refactor of some of this naming, but this seems like a good improvement regardless

--

PiperOrigin-RevId: 248827005

Upstream the Quantizer tool (part 3).

    This upstreams the config and constraints for a reference quantization scheme based on the FxpMathOps dialect.

    There are probably two more CLs to get the rest: one with the passes/tests, and one with the tool main() itself.

--

PiperOrigin-RevId: 248817505

Add support for saving and restoring the insertion point of a FuncBuilder. This also updates the edsc::ScopedContext to use a single builder that saves/restores insertion points. This is necessary for using edscs within RewritePatterns.

--

PiperOrigin-RevId: 248812645

Refactor PatternRewriter to inherit from FuncBuilder instead of Builder. This is necessary for allowing more complicated rewrites in the future that may do things like update the insertion point (e.g. for rewrites involving regions).

--

PiperOrigin-RevId: 248803153

Also visit memref element type in AsmPrinter

--

PiperOrigin-RevId: 248797935

Enable EDSC API test running through lit

    EDSC subsystem contains an API test which is a .cpp file calling the API in
    question and producing IR.  This IR is further checked using FileCheck and
    should plug into lit.  Provide a CMakeLists.txt to build the test and modify
    the lit configuration to process the source file.

--

PiperOrigin-RevId: 248794443

Allow for the case where ShapedType is a MemRef in fixed point math kernel utils

    MemRef may soon be a subclass of ShapedType.

--

PiperOrigin-RevId: 248788950

Refactor Attribute and Type to use 'classof' instead of 'kindof' internally. If a 'classof' method is not defined, a default implementation will invoke 'kindof' on a derived type. This allows for defining supplementary Attribute/Type classes that expose additional functionality, but do not have a specific kind value. An example of this can be seen in the 'Constant(Float|Index|Int)Ops' that derive from 'ConstantOp'.

--

PiperOrigin-RevId: 248724093

Fix use of variables only used in asserts.
    This otherwise triggers "unused variable" errors in optimized build mode.

--

PiperOrigin-RevId: 248706350

Overload arithmetic operators for SDBM expressions

    Provide an "unsafe" version of the overloaded arithmetic operators for SDBM
    expressions.  These operators expect the operands to be of the right SDBM
    expression subtype and assert if they are not.  They also perform simple
    folding operations as well as some semantically correct operations that
    construct an SDBM expression of a different subtype, e.g., a difference
    expression if the RHS of an operator+ is a negated variable.  These operators
    are scoped in a namespace to allow for a future "safe" version of the operators
    that propagates null expressions to denote the error state when expressions
    have wrong subtypes.

--

PiperOrigin-RevId: 248704153

Implement SDBM and conversion between SDBM and lists of SDBMExpr

    Implement the storage class for striped difference-bound matrices (SDBM) as a
    container with a difference bounds matrix and a list of stripe expressions.  An
    SDBM defines an integer set.  Provide conversion mechanisms between lists of
    SDBM expressions treated as equalities with zero or less-than-or-equal
    inequalities with zero.

--

PiperOrigin-RevId: 248702871

LLVM API updates.

--

PiperOrigin-RevId: 248651086

Update cmake dependencies.

--

PiperOrigin-RevId: 248650428

Fixes a small bug in computing dependence direction vectors, where equality constraint can be created on the wrong loop IVs when source/sink of the dependence are at different loop depths. Adds unit tests for cases where source/sink of the dependence are at varying loop depths.

--

PiperOrigin-RevId: 248627490

Simplify the verification of ExtractElementop.

    Make it clear that it cares about the aggregate type being a vector or tensor and not just that it has a shape.
    Remove redundant validation from the custom method that is now covered by the tablegen'ed verification

    This is related to making MemRefs a ShapedType as well.

--

PiperOrigin-RevId: 248610443

Expand ReturnOp error to include types. NFC.

    Found it a bit easier to see what mismatches occurred when invoking passes doesn't match.

--

PiperOrigin-RevId: 248597286

Don't fail verifying unranked shapes as being the same as this could be valid at runtime.

    tensor<*xf32> could be a tensor<1xf32> at runtime but this verifyShapeMatch would return failure and say function is invalid.

--

PiperOrigin-RevId: 248583038

Unify the 'constantFold' and 'fold' hooks on an operation into just 'fold'. This new unified fold hook will take constant attributes as operands, and may return an existing 'Value *' or a constant 'Attribute' when folding. This removes the awkward situation where a simple canonicalization like "sub(x,x)->0" had to be written as a canonicalization pattern as opposed to a fold.

--

PiperOrigin-RevId: 248582024

Add linalg.range_intersect conversion to LLVM.

    This CL adds lowering for linalg.range_intersect into LLVM by computing:
      * new_min <- max (range1.min, range2.min)
      * new_max <- min (range1.max, range2.max)
      * new_step <- range1.step * range2.step

--

PiperOrigin-RevId: 248571810

Add a linalg.range_intersect op.

    This CL adds an operation whose purpose is to encode boundary conditions directly in the view type. In particular, full/partial tile distinction can
    occur at the level of metadata only.
    This CL also adopts a Linalg_Op pattern that is similar to Std_Op.

--

PiperOrigin-RevId: 248529469

Rename VectorOrTensorType to ShapedType

    This is in preparation for making it also support/be a parent class of MemRefType. MemRefs have similar shape/rank/element semantics and it would be useful to be able to use these same utilities for them.

    This CL should not change any semantics and only change variables, types, string literals, and comments. In follow-up CLs I will prepare all callers to handle MemRef types or remove their dependence on ShapedType.

    Discussion/Rationale in https://groups.google.com/a/tensorflow.org/forum/#!topic/mlir/cHLoyfGu8y8

--

PiperOrigin-RevId: 248476449

Store the child function analysis maps of a ModuleAnalysisManager by unique_ptr instead of by-value.

--

PiperOrigin-RevId: 248456926

Add a new tutorial document that details how to define Dialect Attributes and Types.

--

PiperOrigin-RevId: 248417063

Upstreaming Quantizer tool (part 2).

    This adds some additional core types and utilities, notably the constraint analysis graph (CAG) structures, associated metadata and configuration policy object base class.

    The CAG is not particularly memory efficient as it stands now. I had started some work to turn it into a form that could be better managed by a bump pointer allocator but abandoned that for now in favor of having something that does semantically what I was going for as a starting point.

--

PiperOrigin-RevId: 248413133

Fixed Attributes.h comment typo from vecctor to vector

--

PiperOrigin-RevId: 248369005

Cleanup linalg integration test

    This CL performs post-commit cleanups.
    It adds the ability to specify which shared libraries to load dynamically in ExecutionEngine. The linalg integration test is updated to use a shared library.
    Additional minor cleanups related to LLVM lowering of Linalg are also included.

--

PiperOrigin-RevId: 248346589

Add support for parsing/printing dialect defined attributes. This also adds support for a pretty syntax for dialects attributes that is synonymous with the pretty syntax for dialect types. This cl also adds a new attribute 'OpaqueAttr' that allows for roundtripping attributes attached to unregistered dialects.

    Dialect attributes have the following syntax:
       dialect-attribute  ::= `#` dialect-namespace `<` `"` attr-data `"` `>`
       dialect-attribute  ::= `#` alias-name pretty-dialect-sym-body?

--

PiperOrigin-RevId: 248344416

Remove some extraneous const qualifiers on Type, and 0b1 -> 1 in tblgen files. (NFC)

--

PiperOrigin-RevId: 248332674

Make Linalg tiling a FunctionPass instead of a ModulePass - NFC

--

PiperOrigin-RevId: 248286354

Add a new document detailing the diagnostics infrastructure.

--

PiperOrigin-RevId: 248275851

Start to introduce the "Quantizer" tool, which is responsible for transforming a computation expressed in floating point to one operating in terms of quantized types (where possible), either using quant-aware-training hints where available or post-training statistics.

    This is being integrated from an experimental side repository piece by piece over the course of several patches and will ultimately include full build support, documentation and e2e tests.

--

PiperOrigin-RevId: 248259895

Add support for a Linalg base op class

    This CL uses a pattern proposed by aminim@ to add a base Linalg op that further dispatches to the proper op implementation.
    This CL adds a LinalgOp which implements isclassof for only a subset of the linalg ops: the ops that behave like a library call for the purpose of transformations like tiling.
    This uses a static dispatch mechanism based on the LinalgLibraryOps.td ops declarations to avoid switch or visitor patterns. This may later be replaced by Tablegen'd dispatch when it is available.

    As a consequence, the list of library like operations in Linalg may now grow without having to modify any of the dispatch or transformation support.

    More details in the concept-based dispatch, as explained by aminim@
    ```
    This is inspired by Sean Parent's: https://sean-parent.stlab.cc/papers-and-presentations/#value-semantics-and-concept-based-polymorphism

    A key difference is that the set of classes erased is statically known, which avoids to use dynamic memory allocation.
    We use a zero-sized templated class to emit the virtual table and generate a singleton object for each instantiation of this class. We pay the cost of initialization once on construction (find which class to dispatch to) and then a virtual dispatch on every call.
    ```

--

PiperOrigin-RevId: 248258921

Remove unnecessary C++ specifier in CPP files. NFC.

    These are only required in .h files to disambiguate between C and C++ header files.

--

PiperOrigin-RevId: 248219135

Add an AffineExpr matcher

    This CL gives a pattern-matching-y look and feel to AffineExpr.
    For now this uses a shared_ptr instead of unique'ing into a bumpPtrAllocator.
    SDBM gives a simple use case with more idiomatic syntax for matchers.

--

PiperOrigin-RevId: 248188075

Move Quantization -> Dialect/QuantOps, FxpMathOps -> Dialect/FxpMathOps.

    Adding the additional layer of directory was discussed offline and matches the Target/ tree. The names match the defacto convention we seem to be following where the C++ namespace is ^(.+)Ops/$ matched against the directory name.

    This is in preparation for patching the Quantizer into this tree, which would have been confusing without moving the Quantization dialect to its more proper home. It is left to others to move other dialects if desired.

    Tested:
      ninja check-mlir

--

PiperOrigin-RevId: 248171982

When converting a location to an SMLoc, advance to the first non-whitespace if the column is unknown(zero). This also fixes a small bug with call stack printing.

    Example:
    /tmp/file_C.py:21:5: error: 'foo.bar' op attribute 'something'
        raise app.UsageError('Too many command-line arguments.')
        ^
    /tmp/file_D.py:20:3: note: called from
      if len(argv) > 1:
      ^
    /tmp/file_E.py:19:1: note: called from
    def main(argv):
    ^
    /tmp/file_F.py:24:3: note: called from
      app.run(main)
      ^

--

PiperOrigin-RevId: 248151212

[ODS] Add definition for TypeAttr

--

PiperOrigin-RevId: 248147938

Move specification of print, parse and verify to Std_Op base.

    Removes some boilerplate in ops, add support to refer to C++ class name from parser function specification in ODS.

--

PiperOrigin-RevId: 248140977

Add initial support to the SourceMgrDiagnosticHandler for printing call stacks.

    Example:

    /tmp/file_C.py:17:1: error: 'foo.bar' op attribute 'something' ...
      app.run(main)
    ^
    /tmp/file_D.py:14:1: note: called from
        raise app.UsageError('Too many command-line arguments.')
    ^
    /tmp/file_E.py:12:1: note: called from
    def main(argv):
    ^
    /tmp/file_F.py:13:1: note: called from
      if len(argv) > 1:
    ^

--

PiperOrigin-RevId: 248074804

Fix lingering sign compare warnings in exposed by "ninja check-mlir".

--

PiperOrigin-RevId: 248050178

Add a linalg.dim

    A linalg.dim operation is used to extract size information from !linalg.view objects passed
    through function call boundaries.

--

PiperOrigin-RevId: 248017488

Refactor NameLoc so that it also holds a child location. This removes the awkward use of CallSiteLoc as a variable usage location.

--

PiperOrigin-RevId: 248014642

Update "Table-driven Op Definition Specification" doc

    This CL turns the previous "Op Definition" doc into a manual for table-driven
    op definition specification by fleshing out more details of existing mechanisms.

--

PiperOrigin-RevId: 248013274