summaryrefslogtreecommitdiffstats
path: root/mlir/tools/mlir-tblgen/RewriterGen.cpp
Commit message (Collapse)AuthorAgeFilesLines
...
* [TableGen] Enforce constraints on attributesLei Zhang2019-04-051-9/+29
| | | | | | | | | | | | | | Previously, attribute constraints are basically unused: we set true for almost anything. This CL refactors common attribute kinds and sets constraints on them properly. And fixed verification failures found by this change. A noticeable one is that certain TF ops' attributes are required to be 64-bit integer, but the corresponding TFLite ops expect 32-bit integer attributes. Added bitwidth converters to handle this difference. -- PiperOrigin-RevId: 241944008
* [TableGen] Add PatternSymbolResolver for resolving symbols bound in patternsLei Zhang2019-04-051-62/+159
| | | | | | | | | | | | | | | We can bind symbols to op arguments/results in source pattern and op results in result pattern. Previously resolving these symbols is scattered across RewriterGen.cpp. This CL aggregated them into a `PatternSymbolResolver` class. While we are here, this CL also cleans up tests for patterns to make them more focused. Specifically, one-op-one-result.td is superseded by pattern.td; pattern-tAttr.td is simplified; pattern-bound-symbol.td is added for the change in this CL. -- PiperOrigin-RevId: 241913973
* [TableGen] Allow additional result patterns not directly used for ↵Lei Zhang2019-04-031-6/+15
| | | | | | | | | | | | | | | replacement This CL looses the requirement that all result patterns in a rewrite rule must replace a result of the root op in the source pattern. Now only the last N result pattern-generated ops are used to replace a N-result source op. This allows to generate additional ops to aid building up final ops used to replace the source op. -- PiperOrigin-RevId: 241783192
* [TableGen] Add EnumAttrCase and EnumAttrLei Zhang2019-04-011-8/+14
| | | | | | | | | | This CL adds EnumAttr as a general mechanism for modelling enum attributes. Right now it is using StringAttr under the hood since MLIR does not have native support for enum attributes. -- PiperOrigin-RevId: 241334043
* [TableGen] Support benefit score in pattern definition.Feng Liu2019-03-291-5/+1
| | | | | | | | A integer number can be specified in the pattern definition and used as the adjustment to the default benefit score in the generated rewrite pattern C++ definition. PiperOrigin-RevId: 240994192
* Replace remaining usages of the Instruction class with Operation.River Riddle2019-03-291-4/+4
| | | | PiperOrigin-RevId: 240777521
* Replace usages of Instruction with Operation in the /IR directory.River Riddle2019-03-291-3/+3
| | | | | | This is step 2/N to renaming Instruction to Operation. PiperOrigin-RevId: 240459216
* Add a trait to set the result type by attributeFeng Liu2019-03-291-1/+2
| | | | | | | | | Before this CL, the result type of the pattern match results need to be as same as the first operand type, operand broadcast type or a generic tensor type. This CL adds a new trait to set the result type by attribute. For example, the TFL_ConstOp can use this to set the output type to its value attribute. PiperOrigin-RevId: 240441249
* [TableGen] Consolidate constraint related conceptsLei Zhang2019-03-291-29/+31
| | | | | | | | | | | | | | | | | | | Previously we have multiple mechanisms to specify op definition and match constraints: TypeConstraint, AttributeConstraint, Type, Attr, mAttr, mAttrAnyOf, mPat. These variants are not added because there are so many distinct cases we need to model; essentially, they are all carrying a predicate. It's just an artifact of implementation. It's quite confusing for users to grasp these variants and choose among them. Instead, as the OpBase TableGen file, we need to strike to provide an unified mechanism. Each dialect has the flexibility to define its own aliases if wanted. This CL removes mAttr, mAttrAnyOf, mPat. A new base class, Constraint, is added. Now TypeConstraint and AttrConstraint derive from Constraint. Type and Attr further derive from TypeConstraint and AttrConstraint, respectively. Comments are revised and examples are added to make it clear how to use constraints. PiperOrigin-RevId: 240125076
* Remove some statements that required >C++11, add includes and qualify names. ↵Jacques Pienaar2019-03-291-2/+2
| | | | | | NFC. PiperOrigin-RevId: 239197784
* Change Value to NamedTypeConstraint and use TypeConstraint.Jacques Pienaar2019-03-291-5/+4
| | | | | | Previously Value was a pair of name & Type, but for operands/result a TypeConstraint rather then a Type is specified. Update C++ side to match declarative side. PiperOrigin-RevId: 238984799
* [TableGen] Support nested dag attributes arguments in the result patternFeng Liu2019-03-291-34/+68
| | | | | | | | | | Add support to create a new attribute from multiple attributes. It extended the DagNode class to represent attribute creation dag. It also changed the RewriterGen::emitOpCreate method to support this nested dag emit. An unit test is added. PiperOrigin-RevId: 238090229
* [TableGen] Change to attach the name to DAG operator in result patternsLei Zhang2019-03-291-14/+14
| | | | | | | | | | | | There are two ways that we can attach a name to a DAG node: 1) (Op:$name ...) 2) (Op ...):$name The problem with 2) is that we cannot do it on the outmost DAG node in a tree. Switch from 2) to 1). PiperOrigin-RevId: 237513962
* [TableGen] Support multiple result patternsLei Zhang2019-03-291-11/+56
| | | | | | | | | | | | | | | | | | | | | | | | This CL added the ability to generate multiple ops using multiple result patterns, with each of them replacing one result of the matched source op. Specifically, the syntax is ``` def : Pattern<(SourceOp ...), [(ResultOp1 ...), (ResultOp2 ...), (ResultOp3 ...)]>; ``` Assuming `SourceOp` has three results. Currently we require that each result op must generate one result, which can be lifted later when use cases arise. To help with cases that certain output is unused and we don't care about it, this CL also introduces a new directive: `verifyUnusedValue`. Checks will be emitted in the `match()` method to make sure if the corresponding output is not unused, `match()` returns with `matchFailure()`. PiperOrigin-RevId: 237513904
* [TableGen] Fix using rewrite()'s qualified name for a bound argument in match()Lei Zhang2019-03-291-9/+18
| | | | PiperOrigin-RevId: 235767304
* [TableGen] Fix discrepancy between parameter meaning and code logicLei Zhang2019-03-291-1/+1
| | | | | | | | | | The parameter to emitStandaloneParamBuilder() was renamed from hasResultType to isAllSameType, which is the opposite boolean value. The logic should be changed to make them consistent. Also re-ordered some methods in Operator. And few other tiny improvements. PiperOrigin-RevId: 234478316
* [TableGen] Rename Operand to Value to prepare sharing between operand and resultLei Zhang2019-03-291-3/+3
| | | | | | | We specify op operands and results in TableGen op definition using the same syntax. They should be modelled similarly in TableGen driver wrapper classes. PiperOrigin-RevId: 234153332
* [TFLite] Fuse AddOp into preceding convolution opsLei Zhang2019-03-291-5/+0
| | | | | | | | | | | If we see an add op adding a constant value to a convolution op with constant bias, we can fuse the add into the convolution op by constant folding the bias and the add op's constant operand. This CL also removes dangling RewriterGen check that prevents us from using nested DAG nodes in result patterns, which is already supported. PiperOrigin-RevId: 233989654
* [TableGen] Use deduced result types for build() of suitable opsLei Zhang2019-03-291-2/+7
| | | | | | | | | | | | | For ops with the SameOperandsAndResultType trait, we know that all result types should be the same as the first operand's type. So we can generate a build() method without requiring result types as parameters and also invoke this method when constructing such ops during expanding rewrite patterns. Similarly for ops have broadcast behavior, we can define build() method to use the deduced type as the result type. So we can also calling into this build() method when constructing ops in RewriterGen. PiperOrigin-RevId: 233988307
* Add pattern constraints.Jacques Pienaar2019-03-291-4/+52
| | | | | | Enable matching pattern only if constraint is met. Start with type constraints and more general C++ constraints. PiperOrigin-RevId: 233830768
* [TFLite] Add rewrite pattern to fuse conv ops with Relu6 opLei Zhang2019-03-291-12/+14
| | | | | | | | | * Fixed tfl.conv_2d and tfl.depthwise_conv_2d to have fused activation function attribute * Fixed RewriterGen crash: trying to get attribute match template when the matcher is unspecified (UnsetInit) PiperOrigin-RevId: 233241755
* [TableGen] Support nested DAG nodes in result result op argumentsLei Zhang2019-03-291-3/+40
| | | | | | | | | | This CL allowed developers to write result ops having nested DAG nodes as their arguments. Now we can write ``` def : Pat<(...), (AOp (BOp, ...), AOperand)> ``` PiperOrigin-RevId: 233207225
* [TableGen] Assign created ops to variables and rewrite with ↵Lei Zhang2019-03-291-39/+105
| | | | | | | | | | | | | PatternRewriter::replaceOp() Previously we were using PatternRewrite::replaceOpWithNewOp() to both create the new op inline and rewrite the matched op. That does not work well if we want to generate multiple ops in a sequence. To support that, this CL changed to assign each newly created op to a separate variable. This CL also refactors how PatternEmitter performs the directive dispatch logic. PiperOrigin-RevId: 233206819
* Begin the process of fully removing OperationInst. This patch cleans up ↵River Riddle2019-03-291-2/+2
| | | | | | references to OperationInst in the /include, /AffineOps, and lib/Analysis. PiperOrigin-RevId: 232199262
* [TableGen] Use tblgen::DagLeaf to model DAG argumentsLei Zhang2019-03-291-109/+123
| | | | | | | | | | This CL added a tblgen::DagLeaf wrapper class with several helper methods for handling DAG arguments. It helps to refactor the rewriter generation logic to be more higher level. This CL also added a tblgen::ConstantAttr wrapper class for constant attributes. PiperOrigin-RevId: 232050683
* Add fallback to native code op builder specification for patterns.Jacques Pienaar2019-03-291-13/+42
| | | | | | | | This allow for arbitrarily complex builder patterns which is meant to cover initial cases while the modelling is improved and long tail cases/cases for which expanding the DSL would result in worst overall system. NFC just sorting the emit replace methods alphabetical in the class and file body. PiperOrigin-RevId: 231890352
* Enable using constant attribute as matchers.Jacques Pienaar2019-03-291-0/+1
| | | | | | Straight roll-forward of cl/231322019 that got accidentally reverted in the move. PiperOrigin-RevId: 231791464
* [tablegen] Use tblgen:: classes for NamedAttribute and Operand fieldsLei Zhang2019-03-291-3/+3
| | | | | | This is another step towards hiding raw TableGen API calls. PiperOrigin-RevId: 231580827
* Prefix Operator getter methods with "get" to be consistentLei Zhang2019-03-291-2/+2
| | | | PiperOrigin-RevId: 231416230
* Move google-mlir to google_mlirNicolas Vasilache2019-03-291-1/+0
| | | | | | | Python modules cannot be defined under a directory that has a `-` character in its name inside of Google code. Rename to `google_mlir` which circumvents this limitation. PiperOrigin-RevId: 231329321
* Enable using constant attribute as matchers.Jacques Pienaar2019-03-291-0/+1
| | | | | | Update to allow constant attribute values to be used to match or as result in rewrite rule. Define variable ctx in the matcher to allow matchers to refer to the context of the operation being matched. PiperOrigin-RevId: 231322019
* Add tblgen::Pattern to model Patterns defined in TableGenLei Zhang2019-03-291-130/+95
| | | | | | | Similar to other tblgen:: abstractions, tblgen::Pattern hides the native TableGen API and provides a nicer API that is more coherent with the TableGen definitions. PiperOrigin-RevId: 231285143
* Define mAttr in terms of AttrConstraint.Jacques Pienaar2019-03-291-12/+7
| | | | | | | * Matching an attribute and specifying a attribute constraint is the same thing executionally, so represent it such. * Extract AttrConstraint helper to match TypeConstraint and use that where mAttr was previously used in RewriterGen. PiperOrigin-RevId: 231213580
* Pull TableGen op argument definitions into their own filesLei Zhang2019-03-291-10/+12
| | | | PiperOrigin-RevId: 230923050
* Support op removal patterns in TableGenLei Zhang2019-03-291-15/+59
| | | | | | | | | | This CL adds a new marker, replaceWithValue, to indicate that no new result op is generated by applying a pattern. Instead, the matched DAG is replaced by an existing SSA value. Converted the tf.Identity converter to use the pattern. PiperOrigin-RevId: 230922323
* Start doc generation pass.Jacques Pienaar2019-03-291-1/+1
| | | | | | | | | | Start doc generation pass that generates simple markdown output. The output is formatted simply[1] in markdown, but this allows seeing what info we have, where we can refine the op description (e.g., the inputs is probably redundant), what info is missing (e.g., the attributes could probably have a description). The formatting of the description is still left up to whatever was in the op definition (which luckily, due to the uniformity in the .td file, turned out well but relying on the indentation there is fragile). The mechanism to autogenerate these post changes has not been added yet either. The output file could be run through a markdown formatter too to remove extra spaces. [1]. This is not proposal for final style :) There could also be a discussion around single doc vs multiple (per dialect, per op), whether we want a TOC, whether operands/attributes should be headings or just formatted differently ... PiperOrigin-RevId: 230354538
* TableGen: implement predicate tree and basic simplificationAlex Zinenko2019-03-291-2/+2
| | | | | | | | | | | | | | | | | | | | | | A recent change in TableGen definitions allowed arbitrary AND/OR predicate compositions at the cost of removing known-true predicate simplification. Introduce a more advanced simplification mechanism instead. In particular, instead of folding predicate C++ expressions directly in TableGen, keep them as is and build a predicate tree in TableGen C++ library. The predicate expression-substitution mechanism, necessary to implement complex predicates for nested classes such as `ContainerType`, is replaced by a dedicated predicate. This predicate appears in the predicate tree and can be used for tree matching and separation. More specifically, subtrees defined below such predicate may be subject to different transformations than those that appear above. For example, a subtree known to be true above the substitution predicate is not necessarily true below it. Use the predicate tree structure to eliminate known-true and known-false predicates before code emission, as well as to collapse AND and OR predicates if their value can be deduced based on the value of one child. PiperOrigin-RevId: 229605997
* Add attribute matching and transform to pattern rewrites.Jacques Pienaar2019-03-291-21/+56
| | | | | | | | Start simple with single predicate match & transform rules for attributes. * Its unclear whether modelling Attr predicates will be needed so start with allowing matching attributes with a single predicate. * The input and output attr type often differs and so add ability to specify a transform between the input and output format. PiperOrigin-RevId: 229580879
* TableGen: untie Attr from TypeAlex Zinenko2019-03-291-14/+5
| | | | | | | | | | | | | | | | | | | | | | | | | | In TableGen definitions, the "Type" class has been used for types of things that can be stored in Attributes, but not necessarily present in the MLIR type system. As a consequence, records like "String" or "DerviedAttrBody" were of class "Type", which can be confusing. Furthermore, the "builderCall" field of the "Type" class serves only for attribute construction. Some TableGen "Type" subclasses that correspond to MLIR kinds of types do not have a canonical way of construction only from the data available in TableGen, e.g. MemRefType would require the list of affine maps. This leads to a conclusion that the entities that describe types of objects appearing in Attributes should be independent of "Type": they have some properties "Type"s don't and vice versa. Do not parameterize Tablegen "Attr" class by an instance of "Type". Instead, provide a "constBuilderCall" field that can be used to build an attribute from a constant value stored in TableGen instead of indirectly going through Attribute.Type.builderCall. Some attributes still don't have a "constBuilderCall" because they used to depend on types without a "builderCall". Drop definitions of class "Type" that don't correspond to MLIR Types. Provide infrastructure to define type-dependent attributes and string-backed attributes for convenience. PiperOrigin-RevId: 229570087
* TableGen: extract TypeConstraints from TypeAlex Zinenko2019-03-291-3/+2
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | MLIR has support for type-polymorphic instructions, i.e. instructions that may take arguments of different types. For example, standard arithmetic operands take scalars, vectors or tensors. In order to express such instructions in TableGen, we need to be able to verify that a type object satisfies certain constraints, but we don't need to construct an instance of this type. The existing TableGen definition of Type requires both. Extract out a TypeConstraint TableGen class to define restrictions on types. Define the Type TableGen class as a subclass of TypeConstraint for consistency. Accept records of the TypeConstraint class instead of the Type class as values in the Arguments class when defining operators. Replace the predicate logic TableGen class based on conjunctive normal form with the predicate logic classes allowing for abitrary combinations of predicates using Boolean operators (AND/OR/NOT). The combination is implemented using simple string rewriting of C++ expressions and, therefore, respects the short-circuit evaluation order. No logic simplification is performed at the TableGen level so all expressions must be valid C++. Maintaining CNF using TableGen only would have been complicated when one needed to introduce top-level disjunction. It is also unclear if it could lead to a significantly simpler emitted C++ code. In the future, we may replace inplace predicate string combination with a tree structure that can be simplified in TableGen's C++ driver. Combined, these changes allow one to express traits like ArgumentsAreFloatLike directly in TableGen instead of relying on C++ trait classes. PiperOrigin-RevId: 229398247
* Avoid redundant predicate checking in type matching.Jacques Pienaar2019-03-291-2/+2
| | | | | | | | Expand type matcher template generator to consider a set of predicates that are known to hold. This avoids inserting redundant checking for trivially true predicates (for example predicate that hold according to the op definition). This only targets predicates that trivially holds and does not attempt any logic equivalence proof. PiperOrigin-RevId: 228880468
* Add tblgen::Attribute to wrap around TableGen Attr defsLei Zhang2019-03-291-10/+12
| | | | | | | | This CL added a tblgen::Attribute class to wrap around raw TableGen Record getValue*() calls on Attr defs, which will provide a nicer API for handling TableGen Record. PiperOrigin-RevId: 228581107
* Put Operator and PredCNF into the tblgen namespaceLei Zhang2019-03-291-2/+5
| | | | PiperOrigin-RevId: 228429130
* Add tblgen::Type to wrap around TableGen Type defsLei Zhang2019-03-291-20/+12
| | | | | | | | | | This CL added a tblgen::Type class to wrap around raw TableGen Record getValue*() calls on Type defs, which will provide a nicer API for handling TableGen Record. The PredCNF class is also updated to work together with tblgen::Type. PiperOrigin-RevId: 228429090
* Match attributes in input pattern.Jacques Pienaar2019-03-291-11/+26
| | | | | | | | | | Bind attributes similar to operands. Use to rewrite leakyreulo and const rewrite pattern. The attribute type/attributes are not currently checked so should only be used where the attributes match due to the construction of the op. To support current attribute namespacing, convert __ in attribute name to "$" for matching purposes ('$' is not valid character in variable in TableGen). Some simplification to make it simpler to specify indented ostream and avoid so many spaces. The goal is not to have perfectly formatted code generated but good enough so that its still easy to read for a user. PiperOrigin-RevId: 228183639
* Verify type of operands match those specifed in op registry.Jacques Pienaar2019-03-291-3/+40
| | | | | | | | | | | | | | Expand type to include matcher predicates. Use CNF form to allow specifying combinations of constraints for type. The matching call for the type is used to verify the construction of the operation as well as in rewrite pattern generation. The matching initially includes redundant checks (e.g., even if the operand of the op is guaranteed to satisfy some requirement, it is still checked during matcher generation for now). As well as some of the traits specified now check what the generated code already checks. Some of the traits can be removed in future as the verify method will include the relevant checks based on the op definition already. More work is needed for variadic operands. CNF form is used so that in the follow up redundant checks in the rewrite patterns could be omitted (e.g., when matching a F32Tensor, one does not need to verify that op X's operand 0 is a Tensor if that is guaranteed by op X's definition). The alternative was to have single matcher function specified, but this would not allow for reasoning about what attributes already hold (at the level of PredAtoms). Use this new operand type restrictions to rewrite BiasAdd with floating point operands as declarative pattern. PiperOrigin-RevId: 227991412
* Fix format for empty method definitionLei Zhang2019-03-291-2/+2
| | | | PiperOrigin-RevId: 227840511
* Match the op via isa instead of string compare.Jacques Pienaar2019-03-291-7/+2
| | | | | | | * Match using isa - This limits the rewrite pattern to ops defined in op registry but that is probably better end state (esp. for additional verification). PiperOrigin-RevId: 227598946
* Add builderCall to Type and add constant attr class.Jacques Pienaar2019-03-291-35/+21
| | | | | | With the builder to construct the type on the Type, the appropriate mlir::Type can be constructed where needed. Also add a constant attr class that has the attribute and value as members. PiperOrigin-RevId: 227564789
* Switch rewriters for relu, relu6, placeholder_input, softmax to patterns.Jacques Pienaar2019-03-291-4/+24
| | | | | | Add a constant F32 attribute for use with softmax legalization. PiperOrigin-RevId: 227241643
OpenPOWER on IntegriCloud