Suggested by @lattner in https://discourse.llvm.org/t/rfc-define-precise-arith-semantics/65507/22.
Tested with:
`ninja check-mlir check-mlir-integration check-mlir-mlir-spirv-cpu-runner check-mlir-mlir-vulkan-runner check-mlir-examples`
and `bazel build --config=generic_clang @llvm-project//mlir:all`.
Reviewed By: lattner, Mogball, rriddle, jpienaar, mehdi_amini
Differential Revision: https://reviews.llvm.org/D134762
Attributes are the mechanism for specifying constant data on operations in
places where a variable is never allowed - e.g. the comparison predicate of a
-[`arith.cmpi` operation](Dialects/ArithmeticOps.md#arithcmpi-mlirarithcmpiop), or
-the underlying value of a [`arith.constant` operation](Dialects/ArithmeticOps.md#arithconstant-mlirarithconstantop).
+[`arith.cmpi` operation](Dialects/ArithOps.md#arithcmpi-mlirarithcmpiop), or
+the underlying value of a [`arith.constant` operation](Dialects/ArithOps.md#arithconstant-mlirarithconstantop).
Each operation has an attribute dictionary, which associates a set of attribute
names to attribute values.
Every SSA value, such as operation results or block arguments, in MLIR has a type
defined by the type system. MLIR has an open type system with no fixed list of types,
and there are no restrictions on the abstractions they represent. For example, take
-the following [Arithmetic AddI operation](Dialects/ArithmeticOps.md#arithaddi-mlirarithaddiop):
+the following [Arithmetic AddI operation](Dialects/ArithOps.md#arithaddi-mlirarithaddiop):
```mlir
%result = arith.addi %lhs, %rhs : i64
ecosystem. They allow for defining new [attributes](LangRef.md#attributes),
[operations](LangRef.md#operations), and [types](LangRef.md#type-system).
Dialects are used to model a variety of different abstractions; from traditional
-[arithmetic](Dialects/ArithmeticOps.md) to
+[arithmetic](Dialects/ArithOps.md) to
[pattern rewrites](Dialects/PDLOps.md); and is one of the most fundamental
aspects of MLIR.
def MyDialect : Dialect {
// Here we register the Arithmetic and Func dialect as dependencies of our `MyDialect`.
let dependentDialects = [
- "arith::ArithmeticDialect",
+ "arith::ArithDialect",
"func::FuncDialect"
];
}
Using the above infrastructure, conversions are implemented from
-* [Arithmetic Dialect][MlirArithmeticDialect]
+* [Arith Dialect][MlirArithDialect]
* [GPU Dialect][MlirGpuDialect] : A gpu.module is converted to a `spirv.module`.
A gpu.function within this module is lowered as an entry function.
### Virtual Vector Ops
-Some existing Arithmetic and Vector Dialect on `n-D` `vector` types comprise:
+Some existing Arith and Vector Dialect on `n-D` `vector` types comprise:
```mlir
// Produces a vector<3x7x8xf32>
Attributes are the mechanism for specifying constant data on operations in
places where a variable is never allowed - e.g. the comparison predicate of a
-[`cmpi` operation](Dialects/ArithmeticOps.md#arithcmpi-mlirarithcmpiop). Each operation has an
+[`cmpi` operation](Dialects/ArithOps.md#arithcmpi-mlirarithcmpiop). Each operation has an
attribute dictionary, which associates a set of attribute names to attribute
values. MLIR's builtin dialect provides a rich set of
[builtin attribute values](#builtin-attribute-values) out of the box (such as
## `arith` Dialect Passes
-[include "ArithmeticPasses.md"]
+[include "ArithPasses.md"]
## `func` Dialect Passes
### Splitting floating point vs integer operations
-The MLIR "Arithmetic" dialect splits many integer and floating point operations
+The MLIR "Arith" dialect splits many integer and floating point operations
into different categories, for example `arith.addf` vs `arith.addi` and
`arith.cmpf` vs `arith.cmpi`
([following the design of LLVM](http://llvm.org/docs/LangRef.html#binary-operations)).
```yaml
--- !FileInfo:
- filepath: "/home/user/llvm/mlir/lib/Dialect/Arithmetic/IR/ArithmeticCanonicalization.pdll"
- includes: "/home/user/llvm/mlir/lib/Dialect/Arithmetic/IR;/home/user/llvm/mlir/include"
+ filepath: "/home/user/llvm/mlir/lib/Dialect/Arith/IR/ArithCanonicalization.pdll"
+ includes: "/home/user/llvm/mlir/lib/Dialect/Arith/IR;/home/user/llvm/mlir/include"
```
- filepath: <string> - Absolute file path of the file.
```yaml
--- !FileInfo:
- filepath: "/home/user/llvm/mlir/lib/Dialect/Arithmetic/IR/ArithmeticCanonicalization.td"
- includes: "/home/user/llvm/mlir/lib/Dialect/Arithmetic/IR;/home/user/llvm/mlir/include"
+ filepath: "/home/user/llvm/mlir/lib/Dialect/Arith/IR/ArithCanonicalization.td"
+ includes: "/home/user/llvm/mlir/lib/Dialect/Arith/IR;/home/user/llvm/mlir/include"
```
- filepath: <string> - Absolute file path of the file.
## Conversion Target
For our purposes, we want to convert the compute-intensive `Toy` operations into
-a combination of operations from the `Affine`, `Arithmetic`, `Func`, and `MemRef` dialects
+a combination of operations from the `Affine`, `Arith`, `Func`, and `MemRef` dialects
for further optimization. To start off the lowering, we first define our
conversion target:
// We define the specific operations, or dialects, that are legal targets for
// this lowering. In our case, we are lowering to a combination of the
- // `Affine`, `Arithmetic`, `Func`, and `MemRef` dialects.
- target.addLegalDialect<AffineDialect, arith::ArithmeticDialect,
+ // `Affine`, `Arith`, `Func`, and `MemRef` dialects.
+ target.addLegalDialect<AffineDialect, arith::ArithDialect,
func::FuncDialect, memref::MemRefDialect>();
// We also define the Toy dialect as Illegal so that the conversion will fail
mlir::RewritePatternSet patterns(&getContext());
mlir::populateAffineToStdConversionPatterns(patterns, &getContext());
mlir::cf::populateSCFToControlFlowConversionPatterns(patterns, &getContext());
- mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter,
+ mlir::arith::populateArithToLLVMConversionPatterns(typeConverter,
patterns);
mlir::populateFuncToLLVMConversionPatterns(typeConverter, patterns);
mlir::cf::populateControlFlowToLLVMConversionPatterns(patterns, &getContext());
set(LIBS
${dialect_libs}
${conversion_libs}
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIROptLib
MLIRStandalone
)
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/Dialect.h"
#include "mlir/IR/MLIRContext.h"
#include "mlir/InitAllDialects.h"
mlir::DialectRegistry registry;
registry.insert<mlir::standalone::StandaloneDialect,
- mlir::arith::ArithmeticDialect, mlir::func::FuncDialect>();
+ mlir::arith::ArithDialect, mlir::func::FuncDialect>();
// Add the following to include *all* MLIR Core dialects, or selectively
// include what you need like above. You only need to register dialects that
// will be *parsed* by the tool, not the one generated
#include "toy/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Pass/Pass.h"
// We define the specific operations, or dialects, that are legal targets for
// this lowering. In our case, we are lowering to a combination of the
- // `Affine`, `Arithmetic`, `Func`, and `MemRef` dialects.
- target
- .addLegalDialect<AffineDialect, BuiltinDialect, arith::ArithmeticDialect,
- func::FuncDialect, memref::MemRefDialect>();
+ // `Affine`, `Arith`, `Func`, and `MemRef` dialects.
+ target.addLegalDialect<AffineDialect, BuiltinDialect, arith::ArithDialect,
+ func::FuncDialect, memref::MemRefDialect>();
// We also define the Toy dialect as Illegal so that the conversion will fail
// if any of these operations are *not* converted. Given that we actually want
#include "toy/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Pass/Pass.h"
// We define the specific operations, or dialects, that are legal targets for
// this lowering. In our case, we are lowering to a combination of the
- // `Affine`, `Arithmetic`, `Func`, and `MemRef` dialects.
- target
- .addLegalDialect<AffineDialect, BuiltinDialect, arith::ArithmeticDialect,
- func::FuncDialect, memref::MemRefDialect>();
+ // `Affine`, `Arith`, `Func`, and `MemRef` dialects.
+ target.addLegalDialect<AffineDialect, BuiltinDialect, arith::ArithDialect,
+ func::FuncDialect, memref::MemRefDialect>();
// We also define the Toy dialect as Illegal so that the conversion will fail
// if any of these operations are *not* converted. Given that we actually want
#include "toy/Passes.h"
#include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
-#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
+#include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
RewritePatternSet patterns(&getContext());
populateAffineToStdConversionPatterns(patterns);
populateSCFToControlFlowConversionPatterns(patterns);
- mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter,
- patterns);
+ mlir::arith::populateArithToLLVMConversionPatterns(typeConverter, patterns);
populateMemRefToLLVMConversionPatterns(typeConverter, patterns);
cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns);
populateFuncToLLVMConversionPatterns(typeConverter, patterns);
#include "toy/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Pass/Pass.h"
// We define the specific operations, or dialects, that are legal targets for
// this lowering. In our case, we are lowering to a combination of the
- // `Affine`, `Arithmetic`, `Func`, and `MemRef` dialects.
- target
- .addLegalDialect<AffineDialect, BuiltinDialect, arith::ArithmeticDialect,
- func::FuncDialect, memref::MemRefDialect>();
+ // `Affine`, `Arith`, `Func`, and `MemRef` dialects.
+ target.addLegalDialect<AffineDialect, BuiltinDialect, arith::ArithDialect,
+ func::FuncDialect, memref::MemRefDialect>();
// We also define the Toy dialect as Illegal so that the conversion will fail
// if any of these operations are *not* converted. Given that we actually want
#include "toy/Passes.h"
#include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
-#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
+#include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
RewritePatternSet patterns(&getContext());
populateAffineToStdConversionPatterns(patterns);
populateSCFToControlFlowConversionPatterns(patterns);
- mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter,
- patterns);
+ mlir::arith::populateArithToLLVMConversionPatterns(typeConverter, patterns);
populateMemRefToLLVMConversionPatterns(typeConverter, patterns);
cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns);
populateFuncToLLVMConversionPatterns(typeConverter, patterns);
-//===- ArithmeticToLLVM.h - Arith to LLVM dialect conversion ----*- C++ -*-===//
+//===- ArithToLLVM.h - Arith to LLVM dialect conversion ----*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
//
//===----------------------------------------------------------------------===//
-#ifndef MLIR_CONVERSION_ARITHMETICTOLLVM_ARITHMETICTOLLVM_H
-#define MLIR_CONVERSION_ARITHMETICTOLLVM_ARITHMETICTOLLVM_H
+#ifndef MLIR_CONVERSION_ARITHTOLLVM_ARITHTOLLVM_H
+#define MLIR_CONVERSION_ARITHTOLLVM_ARITHTOLLVM_H
#include <memory>
class RewritePatternSet;
class Pass;
-#define GEN_PASS_DECL_ARITHMETICTOLLVMCONVERSIONPASS
+#define GEN_PASS_DECL_ARITHTOLLVMCONVERSIONPASS
#include "mlir/Conversion/Passes.h.inc"
namespace arith {
-void populateArithmeticToLLVMConversionPatterns(LLVMTypeConverter &converter,
- RewritePatternSet &patterns);
+void populateArithToLLVMConversionPatterns(LLVMTypeConverter &converter,
+ RewritePatternSet &patterns);
} // namespace arith
} // namespace mlir
-#endif // MLIR_CONVERSION_ARITHMETICTOLLVM_ARITHMETICTOLLVM_H
+#endif // MLIR_CONVERSION_ARITHTOLLVM_ARITHTOLLVM_H
--- /dev/null
+//===- ArithToSPIRV.h - Convert Arith to SPIRV dialect -----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_CONVERSION_ARITHTOSPIRV_ARITHTOSPIRV_H
+#define MLIR_CONVERSION_ARITHTOSPIRV_ARITHTOSPIRV_H
+
+#include "mlir/Pass/Pass.h"
+#include <memory>
+
+namespace mlir {
+
+class SPIRVTypeConverter;
+class RewritePatternSet;
+class Pass;
+
+#define GEN_PASS_DECL_CONVERTARITHTOSPIRV
+#include "mlir/Conversion/Passes.h.inc"
+
+namespace arith {
+void populateArithToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
+ RewritePatternSet &patterns);
+
+std::unique_ptr<OperationPass<>> createConvertArithToSPIRVPass();
+} // namespace arith
+} // namespace mlir
+
+#endif // MLIR_CONVERSION_ARITHTOSPIRV_ARITHTOSPIRV_H
+++ /dev/null
-//===- ArithmeticToSPIRV.h - Convert Arith to SPIRV dialect -----*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef MLIR_CONVERSION_ARITHMETICTOSPIRV_ARITHMETICTOSPIRV_H
-#define MLIR_CONVERSION_ARITHMETICTOSPIRV_ARITHMETICTOSPIRV_H
-
-#include "mlir/Pass/Pass.h"
-#include <memory>
-
-namespace mlir {
-
-class SPIRVTypeConverter;
-class RewritePatternSet;
-class Pass;
-
-#define GEN_PASS_DECL_CONVERTARITHMETICTOSPIRV
-#include "mlir/Conversion/Passes.h.inc"
-
-namespace arith {
-void populateArithmeticToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
- RewritePatternSet &patterns);
-
-std::unique_ptr<OperationPass<>> createConvertArithmeticToSPIRVPass();
-} // namespace arith
-} // namespace mlir
-
-#endif // MLIR_CONVERSION_ARITHMETICTOSPIRV_ARITHMETICTOSPIRV_H
#include "mlir/Conversion/AMDGPUToROCDL/AMDGPUToROCDL.h"
#include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
-#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
-#include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h"
+#include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
+#include "mlir/Conversion/ArithToSPIRV/ArithToSPIRV.h"
#include "mlir/Conversion/ArmNeon2dToIntr/ArmNeon2dToIntr.h"
#include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h"
#include "mlir/Conversion/BufferizationToMemRef/BufferizationToMemRef.h"
}
//===----------------------------------------------------------------------===//
-// ArithmeticToLLVM
+// ArithToLLVM
//===----------------------------------------------------------------------===//
-def ArithmeticToLLVMConversionPass : Pass<"convert-arith-to-llvm"> {
- let summary = "Convert Arithmetic dialect to LLVM dialect";
+def ArithToLLVMConversionPass : Pass<"convert-arith-to-llvm"> {
+ let summary = "Convert Arith dialect to LLVM dialect";
let description = [{
- This pass converts supported Arithmetic ops to LLVM dialect instructions.
+ This pass converts supported Arith ops to LLVM dialect instructions.
}];
let dependentDialects = ["LLVM::LLVMDialect"];
let options = [
}
//===----------------------------------------------------------------------===//
-// ArithmeticToSPIRV
+// ArithToSPIRV
//===----------------------------------------------------------------------===//
-def ConvertArithmeticToSPIRV : Pass<"convert-arith-to-spirv"> {
- let summary = "Convert Arithmetic dialect to SPIR-V dialect";
- let constructor = "mlir::arith::createConvertArithmeticToSPIRVPass()";
+def ConvertArithToSPIRV : Pass<"convert-arith-to-spirv"> {
+ let summary = "Convert Arith dialect to SPIR-V dialect";
+ let constructor = "mlir::arith::createConvertArithToSPIRVPass()";
let dependentDialects = ["spirv::SPIRVDialect"];
let options = [
Option<"emulateNon32BitScalarTypes", "emulate-non-32-bit-scalar-types",
}];
let constructor = "mlir::createConvertAsyncToLLVMPass()";
let dependentDialects = [
- "arith::ArithmeticDialect",
+ "arith::ArithDialect",
"async::AsyncDialect",
"LLVM::LLVMDialect",
];
}];
let constructor = "mlir::createBufferizationToMemRefPass()";
- let dependentDialects = ["arith::ArithmeticDialect", "memref::MemRefDialect"];
+ let dependentDialects = ["arith::ArithDialect", "memref::MemRefDialect"];
}
//===----------------------------------------------------------------------===//
}];
let constructor = "mlir::createConvertMathToLibmPass()";
let dependentDialects = [
- "arith::ArithmeticDialect",
+ "arith::ArithDialect",
"func::FuncDialect",
"vector::VectorDialect",
];
}];
let constructor = "mlir::createConvertMathToFuncsPass()";
let dependentDialects = [
- "arith::ArithmeticDialect",
+ "arith::ArithDialect",
"cf::ControlFlowDialect",
"func::FuncDialect",
"vector::VectorDialect",
let summary = "Convert some Tensor dialect ops to Linalg dialect";
let constructor = "mlir::createConvertTensorToLinalgPass()";
let dependentDialects = [
- "arith::ArithmeticDialect",
+ "arith::ArithDialect",
"linalg::LinalgDialect",
];
}
def TosaToArith : Pass<"tosa-to-arith"> {
let summary = "Lower TOSA to the Arith dialect";
let dependentDialects = [
- "arith::ArithmeticDialect",
+ "arith::ArithDialect",
];
let description = [{
Pass that converts TOSA operations to the equivalent operations using the
#ifndef MLIR_DIALECT_AFFINE_ANALYSIS_AFFINEANALYSIS_H
#define MLIR_DIALECT_AFFINE_ANALYSIS_AFFINEANALYSIS_H
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/Value.h"
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/SmallVector.h"
#define MLIR_DIALECT_AFFINE_IR_AFFINEOPS_H
#include "mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/AffineMap.h"
#include "mlir/IR/Builders.h"
#include "mlir/Interfaces/ControlFlowInterfaces.h"
#ifndef AFFINE_OPS
#define AFFINE_OPS
-include "mlir/Dialect/Arithmetic/IR/ArithmeticBase.td"
+include "mlir/Dialect/Arith/IR/ArithBase.td"
include "mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.td"
include "mlir/Interfaces/ControlFlowInterfaces.td"
include "mlir/Interfaces/LoopLikeInterface.td"
let name = "affine";
let cppNamespace = "mlir";
let hasConstantMaterializer = 1;
- let dependentDialects = ["arith::ArithmeticDialect"];
+ let dependentDialects = ["arith::ArithDialect"];
}
// Base class for Affine dialect ops.
let summary = "Coalesce nested loops with independent bounds into a single "
"loop";
let constructor = "mlir::createLoopCoalescingPass()";
- let dependentDialects = ["arith::ArithmeticDialect"];
+ let dependentDialects = ["arith::ArithDialect"];
}
def SimplifyAffineStructures : Pass<"affine-simplify-structures", "func::FuncOp"> {
-//===- Arithmetic.h - Arithmetic dialect --------------------------*- C++-*-==//
+//===- Arith.h - Arith dialect ----0000000000----------------------*- C++-*-==//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
-#ifndef MLIR_DIALECT_ARITHMETIC_IR_ARITHMETIC_H_
-#define MLIR_DIALECT_ARITHMETIC_IR_ARITHMETIC_H_
+#ifndef MLIR_DIALECT_ARITH_IR_ARITH_H_
+#define MLIR_DIALECT_ARITH_IR_ARITH_H_
#include "mlir/IR/Dialect.h"
#include "mlir/IR/OpDefinition.h"
#include "mlir/Interfaces/VectorInterfaces.h"
//===----------------------------------------------------------------------===//
-// ArithmeticDialect
+// ArithDialect
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/ArithmeticOpsDialect.h.inc"
+#include "mlir/Dialect/Arith/IR/ArithOpsDialect.h.inc"
//===----------------------------------------------------------------------===//
-// Arithmetic Dialect Enum Attributes
+// Arith Dialect Enum Attributes
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/ArithmeticOpsEnums.h.inc"
+#include "mlir/Dialect/Arith/IR/ArithOpsEnums.h.inc"
//===----------------------------------------------------------------------===//
-// Arithmetic Dialect Operations
+// Arith Dialect Operations
//===----------------------------------------------------------------------===//
#define GET_OP_CLASSES
-#include "mlir/Dialect/Arithmetic/IR/ArithmeticOps.h.inc"
+#include "mlir/Dialect/Arith/IR/ArithOps.h.inc"
namespace mlir {
namespace arith {
} // namespace arith
} // namespace mlir
-#endif // MLIR_DIALECT_ARITHMETIC_IR_ARITHMETIC_H_
+#endif // MLIR_DIALECT_ARITH_IR_ARITH_H_
-//===- ArithmeticBase.td - Base defs for arith dialect ------*- tablegen -*-==//
+//===- ArithBase.td - Base defs for arith dialect -----------*- tablegen -*-==//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
//
//===----------------------------------------------------------------------===//
-#ifndef ARITHMETIC_BASE
-#define ARITHMETIC_BASE
+#ifndef ARITH_BASE
+#define ARITH_BASE
include "mlir/IR/EnumAttr.td"
include "mlir/IR/OpBase.td"
-def Arithmetic_Dialect : Dialect {
+def Arith_Dialect : Dialect {
let name = "arith";
let cppNamespace = "::mlir::arith";
let description = [{
- The arithmetic dialect is intended to hold basic integer and floating point
+ The arith dialect is intended to hold basic integer and floating point
mathematical operations. This includes unary, binary, and ternary arithmetic
ops, bitwise and shift ops, cast ops, and compare ops. Operations in this
dialect also accept vectors and tensors of integers or floats.
let cppNamespace = "::mlir::arith";
}
-#endif // ARITHMETIC_BASE
+#endif // ARITH_BASE
-//===- ArithmeticOps.td - Arithmetic op definitions --------*- tablegen -*-===//
+//===- ArithOps.td - Arith op definitions -------------*- tablegen -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
//
//===----------------------------------------------------------------------===//
-#ifndef ARITHMETIC_OPS
-#define ARITHMETIC_OPS
+#ifndef ARITH_OPS
+#define ARITH_OPS
-include "mlir/Dialect/Arithmetic/IR/ArithmeticBase.td"
+include "mlir/Dialect/Arith/IR/ArithBase.td"
include "mlir/Interfaces/CastInterfaces.td"
include "mlir/Interfaces/InferIntRangeInterface.td"
include "mlir/Interfaces/InferTypeOpInterface.td"
include "mlir/IR/BuiltinAttributeInterfaces.td"
include "mlir/IR/OpAsmInterface.td"
-// Base class for Arithmetic dialect ops. Ops in this dialect have no side
+// Base class for Arith dialect ops. Ops in this dialect have no side
// effects and can be applied element-wise to vectors and tensors.
class Arith_Op<string mnemonic, list<Trait> traits = []> :
- Op<Arithmetic_Dialect, mnemonic, traits # [NoSideEffect,
+ Op<Arith_Dialect, mnemonic, traits # [NoSideEffect,
DeclareOpInterfaceMethods<VectorUnrollOpInterface>] #
ElementwiseMappable.traits>;
// Base class for integer and floating point arithmetic ops. All ops have one
// result, require operands and results to be of the same type, and can accept
// tensors or vectors of integers or floats.
-class Arith_ArithmeticOp<string mnemonic, list<Trait> traits = []> :
+class Arith_ArithOp<string mnemonic, list<Trait> traits = []> :
Arith_Op<mnemonic, traits # [SameOperandsAndResultType]>;
// Base class for unary arithmetic operations.
class Arith_UnaryOp<string mnemonic, list<Trait> traits = []> :
- Arith_ArithmeticOp<mnemonic, traits> {
+ Arith_ArithOp<mnemonic, traits> {
let assemblyFormat = "$operand attr-dict `:` type($result)";
}
// Base class for binary arithmetic operations.
class Arith_BinaryOp<string mnemonic, list<Trait> traits = []> :
- Arith_ArithmeticOp<mnemonic, traits> {
+ Arith_ArithOp<mnemonic, traits> {
let assemblyFormat = "$lhs `,` $rhs attr-dict `:` type($result)";
}
// Base class for ternary arithmetic operations.
class Arith_TernaryOp<string mnemonic, list<Trait> traits = []> :
- Arith_ArithmeticOp<mnemonic, traits> {
+ Arith_ArithOp<mnemonic, traits> {
let assemblyFormat = "$a `,` $b `,` $c attr-dict `:` type($result)";
}
// ConstantOp
//===----------------------------------------------------------------------===//
-def Arith_ConstantOp : Op<Arithmetic_Dialect, "constant",
+def Arith_ConstantOp : Op<Arith_Dialect, "constant",
[ConstantLike, NoSideEffect,
DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
AllTypesMatch<["value", "result"]>,
let arguments = (ins TypedAttrInterface:$value);
// TODO: Disallow arith.constant to return anything other than a signless
- // integer or float like. Downstream users of Arithmetic should only be
+ // integer or float like. Downstream users of Arith should only be
// working with signless integers, floats, or vectors/tensors thereof.
// However, it is necessary to allow arith.constant to return vectors/tensors
// of strings and signed/unsigned integers (for now) as an artefact of
let hasCustomAssemblyFormat = 1;
}
-#endif // ARITHMETIC_OPS
+#endif // ARITH_OPS
--- /dev/null
+set(LLVM_TARGET_DEFINITIONS ArithOps.td)
+mlir_tablegen(ArithOpsEnums.h.inc -gen-enum-decls)
+mlir_tablegen(ArithOpsEnums.cpp.inc -gen-enum-defs)
+add_mlir_dialect(ArithOps arith)
+add_mlir_doc(ArithOps ArithOps Dialects/ -gen-dialect-doc)
//
//===----------------------------------------------------------------------===//
-#ifndef MLIR_DIALECT_ARITHMETIC_BUFFERIZABLEOPINTERFACEIMPL_H
-#define MLIR_DIALECT_ARITHMETIC_BUFFERIZABLEOPINTERFACEIMPL_H
+#ifndef MLIR_DIALECT_ARITH_BUFFERIZABLEOPINTERFACEIMPL_H
+#define MLIR_DIALECT_ARITH_BUFFERIZABLEOPINTERFACEIMPL_H
namespace mlir {
} // namespace arith
} // namespace mlir
-#endif // MLIR_DIALECT_ARITHMETIC_BUFFERIZABLEOPINTERFACEIMPL_H
+#endif // MLIR_DIALECT_ARITH_BUFFERIZABLEOPINTERFACEIMPL_H
--- /dev/null
+set(LLVM_TARGET_DEFINITIONS Passes.td)
+mlir_tablegen(Passes.h.inc -gen-pass-decls -name Arith)
+add_public_tablegen_target(MLIRArithTransformsIncGen)
+
+add_mlir_doc(Passes ArithPasses ./ -gen-pass-doc)
//
//===----------------------------------------------------------------------===//
-#ifndef MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES_H_
-#define MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES_H_
+#ifndef MLIR_DIALECT_ARITH_TRANSFORMS_PASSES_H_
+#define MLIR_DIALECT_ARITH_TRANSFORMS_PASSES_H_
#include "mlir/Pass/Pass.h"
namespace arith {
#define GEN_PASS_DECL
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
+#include "mlir/Dialect/Arith/Transforms/Passes.h.inc"
class WideIntEmulationConverter;
-/// Create a pass to bufferize Arithmetic ops.
-std::unique_ptr<Pass> createArithmeticBufferizePass();
+/// Create a pass to bufferize Arith ops.
+std::unique_ptr<Pass> createArithBufferizePass();
/// Create a pass to bufferize arith.constant ops.
std::unique_ptr<Pass> createConstantBufferizePass(uint64_t alignment = 0);
-/// Adds patterns to emulate wide Arithmetic and Function ops over integer
+/// Adds patterns to emulate wide Arith and Function ops over integer
/// types into supported ones. This is done by splitting original power-of-two
/// i2N integer types into two iN halves.
void populateWideIntEmulationPatterns(WideIntEmulationConverter &typeConverter,
RewritePatternSet &patterns);
-/// Add patterns to expand Arithmetic ops for LLVM lowering.
-void populateArithmeticExpandOpsPatterns(RewritePatternSet &patterns);
+/// Add patterns to expand Arith ops for LLVM lowering.
+void populateArithExpandOpsPatterns(RewritePatternSet &patterns);
-/// Create a pass to legalize Arithmetic ops for LLVM lowering.
-std::unique_ptr<Pass> createArithmeticExpandOpsPass();
+/// Create a pass to legalize Arith ops for LLVM lowering.
+std::unique_ptr<Pass> createArithExpandOpsPass();
/// Create a pass to replace signed ops with unsigned ones where they are proven
/// equivalent.
-std::unique_ptr<Pass> createArithmeticUnsignedWhenEquivalentPass();
+std::unique_ptr<Pass> createArithUnsignedWhenEquivalentPass();
//===----------------------------------------------------------------------===//
// Registration
/// Generate the code for registering passes.
#define GEN_PASS_REGISTRATION
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
+#include "mlir/Dialect/Arith/Transforms/Passes.h.inc"
} // namespace arith
} // namespace mlir
-#endif // MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES_H_
+#endif // MLIR_DIALECT_ARITH_TRANSFORMS_PASSES_H_
-//===-- Passes.td - Arithmetic pass definition file --------*- tablegen -*-===//
+//===-- Passes.td - Arith pass definition file --------*- tablegen -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
//
//===----------------------------------------------------------------------===//
-#ifndef MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES
-#define MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES
+#ifndef MLIR_DIALECT_ARITH_TRANSFORMS_PASSES
+#define MLIR_DIALECT_ARITH_TRANSFORMS_PASSES
include "mlir/Pass/PassBase.td"
-def ArithmeticBufferize : Pass<"arith-bufferize", "ModuleOp"> {
- let summary = "Bufferize Arithmetic dialect ops.";
+def ArithBufferize : Pass<"arith-bufferize", "ModuleOp"> {
+ let summary = "Bufferize Arith dialect ops.";
let description = [{
This pass bufferizes arith dialect ops.
multi-threading. Most other bufferization passes can run in parallel at
function granularity.
}];
- let constructor = "mlir::arith::createArithmeticBufferizePass()";
+ let constructor = "mlir::arith::createArithBufferizePass()";
let options = [
Option<"alignment", "alignment", "unsigned", /*default=*/"0",
"Create global memrefs with a specified alignment">,
];
}
-def ArithmeticExpandOps : Pass<"arith-expand"> {
- let summary = "Legalize Arithmetic ops to be convertible to LLVM.";
- let constructor = "mlir::arith::createArithmeticExpandOpsPass()";
+def ArithExpandOps : Pass<"arith-expand"> {
+ let summary = "Legalize Arith ops to be convertible to LLVM.";
+ let constructor = "mlir::arith::createArithExpandOpsPass()";
}
-def ArithmeticUnsignedWhenEquivalent : Pass<"arith-unsigned-when-equivalent"> {
+def ArithUnsignedWhenEquivalent : Pass<"arith-unsigned-when-equivalent"> {
let summary = "Replace signed ops with unsigned ones where they are proven equivalent";
let description = [{
Replace signed ops with their unsigned equivalents when integer range analysis
The affect ops include division, remainder, shifts, min, max, and integer
comparisons.
}];
- let constructor = "mlir::arith::createArithmeticUnsignedWhenEquivalentPass()";
+ let constructor = "mlir::arith::createArithUnsignedWhenEquivalentPass()";
}
-def ArithmeticEmulateWideInt : Pass<"arith-emulate-wide-int"> {
+def ArithEmulateWideInt : Pass<"arith-emulate-wide-int"> {
let summary = "Emulate 2*N-bit integer operations using N-bit operations";
let description = [{
Emulate integer operations that use too wide integer types with equivalent
let dependentDialects = ["vector::VectorDialect"];
}
-#endif // MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES
+#endif // MLIR_DIALECT_ARITH_TRANSFORMS_PASSES
//
//===----------------------------------------------------------------------===//
-#ifndef MLIR_DIALECT_ARITHMETIC_WIDE_INT_EMULATION_CONVERTER_H_
-#define MLIR_DIALECT_ARITHMETIC_WIDE_INT_EMULATION_CONVERTER_H_
+#ifndef MLIR_DIALECT_ARITH_WIDE_INT_EMULATION_CONVERTER_H_
+#define MLIR_DIALECT_ARITH_WIDE_INT_EMULATION_CONVERTER_H_
#include "mlir/Transforms/DialectConversion.h"
};
} // namespace mlir::arith
-#endif // MLIR_DIALECT_ARITHMETIC_WIDE_INT_EMULATION_CONVERTER_H_
+#endif // MLIR_DIALECT_ARITH_WIDE_INT_EMULATION_CONVERTER_H_
-//===- Utils.h - General Arithmetic transformation utilities ----*- C++ -*-===//
+//===- Utils.h - General Arith transformation utilities ----*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
//===----------------------------------------------------------------------===//
//
// This header file defines prototypes for various transformation utilities for
-// the Arithmetic dialect. These are not passes by themselves but are used
+// the Arith dialect. These are not passes by themselves but are used
// either by passes, optimization sequences, or in turn by other transformation
// utilities.
//
//===----------------------------------------------------------------------===//
-#ifndef MLIR_DIALECT_ARITHMETIC_UTILS_UTILS_H
-#define MLIR_DIALECT_ARITHMETIC_UTILS_UTILS_H
+#ifndef MLIR_DIALECT_ARITH_UTILS_UTILS_H
+#define MLIR_DIALECT_ARITH_UTILS_UTILS_H
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/Matchers.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/IR/Value.h"
};
} // namespace mlir
-#endif // MLIR_DIALECT_ARITHMETIC_UTILS_UTILS_H
+#endif // MLIR_DIALECT_ARITH_UTILS_UTILS_H
+++ /dev/null
-set(LLVM_TARGET_DEFINITIONS ArithmeticOps.td)
-mlir_tablegen(ArithmeticOpsEnums.h.inc -gen-enum-decls)
-mlir_tablegen(ArithmeticOpsEnums.cpp.inc -gen-enum-defs)
-add_mlir_dialect(ArithmeticOps arith)
-add_mlir_doc(ArithmeticOps ArithmeticOps Dialects/ -gen-dialect-doc)
+++ /dev/null
-set(LLVM_TARGET_DEFINITIONS Passes.td)
-mlir_tablegen(Passes.h.inc -gen-pass-decls -name Arithmetic)
-add_public_tablegen_target(MLIRArithmeticTransformsIncGen)
-
-add_mlir_doc(Passes ArithmeticPasses ./ -gen-pass-doc)
];
let dependentDialects = [
- "arith::ArithmeticDialect",
+ "arith::ArithDialect",
"async::AsyncDialect",
"scf::SCFDialect"
];
#define MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_BUFFERUTILS_H
#include "mlir/Analysis/Liveness.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/Transforms/BufferViewFlowAnalysis.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h"
add_subdirectory(AMDGPU)
add_subdirectory(AMX)
add_subdirectory(Affine)
-add_subdirectory(Arithmetic)
+add_subdirectory(Arith)
add_subdirectory(ArmNeon)
add_subdirectory(ArmSVE)
add_subdirectory(Async)
arithmetic ops.
}];
- let dependentDialects = ["arith::ArithmeticDialect"];
+ let dependentDialects = ["arith::ArithDialect"];
let hasConstantMaterializer = 1;
let useDefaultAttributePrinterParser = 1;
}
def ControlFlow_Dialect : Dialect {
let name = "cf";
let cppNamespace = "::mlir::cf";
- let dependentDialects = ["arith::ArithmeticDialect"];
+ let dependentDialects = ["arith::ArithDialect"];
let description = [{
This dialect contains low-level, i.e. non-region based, control flow
constructs. These constructs generally represent control flow directly
static unsigned getPrivateAddressSpace() { return 5; }
}];
- let dependentDialects = ["arith::ArithmeticDialect"];
+ let dependentDialects = ["arith::ArithDialect"];
let useDefaultAttributePrinterParser = 1;
let useDefaultTypePrinterParser = 1;
}];
let cppNamespace = "::mlir::linalg";
let dependentDialects = [
- "arith::ArithmeticDialect",
+ "arith::ArithDialect",
"AffineDialect",
"math::MathDialect",
"memref::MemRefDialect",
manipulation ops, which are not strongly associated with any particular
other dialect or domain abstraction.
}];
- let dependentDialects = ["arith::ArithmeticDialect"];
+ let dependentDialects = ["arith::ArithDialect"];
let hasConstantMaterializer = 1;
let emitAccessorPrefix = kEmitAccessorPrefix_Both;
#ifndef MEMREF_OPS
#define MEMREF_OPS
-include "mlir/Dialect/Arithmetic/IR/ArithmeticBase.td"
+include "mlir/Dialect/Arith/IR/ArithBase.td"
include "mlir/Dialect/MemRef/IR/MemRefBase.td"
include "mlir/Interfaces/CastInterfaces.td"
include "mlir/Interfaces/ControlFlowInterfaces.td"
def SCF_Dialect : Dialect {
let name = "scf";
let cppNamespace = "::mlir::scf";
- let dependentDialects = ["arith::ArithmeticDialect"];
+ let dependentDialects = ["arith::ArithDialect"];
}
// Base class for SCF dialect ops.
}];
let cppNamespace = "::mlir::shape";
- let dependentDialects = ["arith::ArithmeticDialect", "tensor::TensorDialect"];
+ let dependentDialects = ["arith::ArithDialect", "tensor::TensorDialect"];
let useDefaultTypePrinterParser = 1;
let hasConstantMaterializer = 1;
#include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
/// Creates an instance of the ShapeToShapeLowering pass that legalizes Shape
-/// dialect to be convertible to Arithmetic. For example, `shape.num_elements`
-/// get transformed to `shape.reduce`, which can be lowered to SCF and
-/// Arithmetic.
+/// dialect to be convertible to Arith. For example, `shape.num_elements` get
+/// transformed to `shape.reduce`, which can be lowered to SCF and Arith.
std::unique_ptr<Pass> createShapeToShapeLowering();
/// Collects a set of patterns to rewrite ops within the Shape dialect.
}
def ShapeToShapeLowering : Pass<"shape-to-shape-lowering", "func::FuncOp"> {
- let summary = "Legalize Shape dialect to be convertible to Arithmetic";
+ let summary = "Legalize Shape dialect to be convertible to Arith";
let constructor = "mlir::createShapeToShapeLowering()";
}
let constructor = "mlir::createSparsificationPass()";
let dependentDialects = [
"AffineDialect",
- "arith::ArithmeticDialect",
+ "arith::ArithDialect",
"bufferization::BufferizationDialect",
"LLVM::LLVMDialect",
"memref::MemRefDialect",
}];
let constructor = "mlir::createSparseTensorConversionPass()";
let dependentDialects = [
- "arith::ArithmeticDialect",
+ "arith::ArithDialect",
"bufferization::BufferizationDialect",
"LLVM::LLVMDialect",
"linalg::LinalgDialect",
}];
let constructor = "mlir::createSparseTensorCodegenPass()";
let dependentDialects = [
- "arith::ArithmeticDialect",
+ "arith::ArithDialect",
"bufferization::BufferizationDialect",
"linalg::LinalgDialect",
"memref::MemRefDialect",
let hasConstantMaterializer = 1;
let dependentDialects = [
- "arith::ArithmeticDialect",
+ "arith::ArithDialect",
"complex::ComplexDialect",
];
}
#ifndef DIALECT_TOSA_UTILS_COVERSION_UTILS_H_
#define DIALECT_TOSA_UTILS_COVERSION_UTILS_H_
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Utils/StructuredOpsUtils.h"
#include "mlir/IR/PatternMatch.h"
let useDefaultAttributePrinterParser = 1;
let hasConstantMaterializer = 1;
- let dependentDialects = ["arith::ArithmeticDialect"];
+ let dependentDialects = ["arith::ArithDialect"];
}
// Base class for Vector dialect ops.
#include "mlir/Dialect/AMDGPU/AMDGPUDialect.h"
#include "mlir/Dialect/AMX/AMXDialect.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Transforms/BufferizableOpInterfaceImpl.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Arith/Transforms/BufferizableOpInterfaceImpl.h"
#include "mlir/Dialect/ArmNeon/ArmNeonDialect.h"
#include "mlir/Dialect/ArmSVE/ArmSVEDialect.h"
#include "mlir/Dialect/Async/IR/Async.h"
// clang-format off
registry.insert<acc::OpenACCDialect,
AffineDialect,
- arith::ArithmeticDialect,
+ arith::ArithDialect,
amdgpu::AMDGPUDialect,
amx::AMXDialect,
arm_neon::ArmNeonDialect,
#include "mlir/Conversion/Passes.h"
#include "mlir/Dialect/Affine/Passes.h"
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
+#include "mlir/Dialect/Arith/Transforms/Passes.h"
#include "mlir/Dialect/Async/Passes.h"
#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
#include "mlir/Dialect/Func/Transforms/Passes.h"
// Dialect passes
registerAffinePasses();
registerAsyncPasses();
- arith::registerArithmeticPasses();
+ arith::registerArithPasses();
bufferization::registerBufferizationPasses();
func::registerFuncPasses();
registerGPUPasses();
"::mlir::SetIntRangeFn":$setResultRanges)
>];
}
-#endif // MLIR_DIALECT_ARITHMETIC_IR_INFERINTRANGEINTERFACE
+#endif // MLIR_INTERFACES_INFERINTRANGEINTERFACE
populateAffineToStdConversionPatterns(patterns);
populateAffineToVectorConversionPatterns(patterns);
ConversionTarget target(getContext());
- target.addLegalDialect<arith::ArithmeticDialect, memref::MemRefDialect,
+ target.addLegalDialect<arith::ArithDialect, memref::MemRefDialect,
scf::SCFDialect, VectorDialect>();
if (failed(applyPartialConversion(getOperation(), target,
std::move(patterns))))
LINK_LIBS PUBLIC
MLIRAffineDialect
MLIRAffineUtils
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRIR
MLIRMemRefDialect
MLIRSCFDialect
-//===- ArithmeticToLLVM.cpp - Arithmetic to LLVM dialect conversion -------===//
+//===- ArithToLLVM.cpp - Arithmetic to LLVM dialect conversion -------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
//
//===----------------------------------------------------------------------===//
-#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
+#include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/VectorPattern.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/IR/TypeUtilities.h"
#include "mlir/Pass/Pass.h"
namespace mlir {
-#define GEN_PASS_DEF_ARITHMETICTOLLVMCONVERSIONPASS
+#define GEN_PASS_DEF_ARITHTOLLVMCONVERSIONPASS
#include "mlir/Conversion/Passes.h.inc"
} // namespace mlir
//===----------------------------------------------------------------------===//
namespace {
-struct ArithmeticToLLVMConversionPass
- : public impl::ArithmeticToLLVMConversionPassBase<
- ArithmeticToLLVMConversionPass> {
+struct ArithToLLVMConversionPass
+ : public impl::ArithToLLVMConversionPassBase<ArithToLLVMConversionPass> {
using Base::Base;
void runOnOperation() override {
options.overrideIndexBitwidth(indexBitwidth);
LLVMTypeConverter converter(&getContext(), options);
- mlir::arith::populateArithmeticToLLVMConversionPatterns(converter,
- patterns);
+ mlir::arith::populateArithToLLVMConversionPatterns(converter, patterns);
if (failed(applyPartialConversion(getOperation(), target,
std::move(patterns))))
// Pattern Population
//===----------------------------------------------------------------------===//
-void mlir::arith::populateArithmeticToLLVMConversionPatterns(
+void mlir::arith::populateArithToLLVMConversionPatterns(
LLVMTypeConverter &converter, RewritePatternSet &patterns) {
// clang-format off
patterns.add<
-add_mlir_conversion_library(MLIRArithmeticToLLVM
- ArithmeticToLLVM.cpp
+add_mlir_conversion_library(MLIRArithToLLVM
+ ArithToLLVM.cpp
ADDITIONAL_HEADER_DIRS
- ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/ArithmeticToLLVM
+ ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/ArithToLLVM
DEPENDS
MLIRConversionPassIncGen
Core
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRLLVMCommonConversion
MLIRLLVMDialect
)
-//===- ArithmeticToSPIRV.cpp - Arithmetic to SPIRV dialect conversion -----===//
+//===- ArithToSPIRV.cpp - Arithmetic to SPIRV dialect conversion -----===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
//
//===----------------------------------------------------------------------===//
-#include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h"
+#include "mlir/Conversion/ArithToSPIRV/ArithToSPIRV.h"
#include "../SPIRVCommon/Pattern.h"
#include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "llvm/Support/Debug.h"
namespace mlir {
-#define GEN_PASS_DEF_CONVERTARITHMETICTOSPIRV
+#define GEN_PASS_DEF_CONVERTARITHTOSPIRV
#include "mlir/Conversion/Passes.h.inc"
} // namespace mlir
// Pattern Population
//===----------------------------------------------------------------------===//
-void mlir::arith::populateArithmeticToSPIRVPatterns(
+void mlir::arith::populateArithToSPIRVPatterns(
SPIRVTypeConverter &typeConverter, RewritePatternSet &patterns) {
// clang-format off
patterns.add<
//===----------------------------------------------------------------------===//
namespace {
-struct ConvertArithmeticToSPIRVPass
- : public impl::ConvertArithmeticToSPIRVBase<ConvertArithmeticToSPIRVPass> {
+struct ConvertArithToSPIRVPass
+ : public impl::ConvertArithToSPIRVBase<ConvertArithToSPIRVPass> {
void runOnOperation() override {
Operation *op = getOperation();
auto targetAttr = spirv::lookupTargetEnvOrDefault(op);
target->addLegalOp<UnrealizedConversionCastOp>();
RewritePatternSet patterns(&getContext());
- arith::populateArithmeticToSPIRVPatterns(typeConverter, patterns);
+ arith::populateArithToSPIRVPatterns(typeConverter, patterns);
if (failed(applyPartialConversion(op, *target, std::move(patterns))))
signalPassFailure();
};
} // namespace
-std::unique_ptr<OperationPass<>>
-mlir::arith::createConvertArithmeticToSPIRVPass() {
- return std::make_unique<ConvertArithmeticToSPIRVPass>();
+std::unique_ptr<OperationPass<>> mlir::arith::createConvertArithToSPIRVPass() {
+ return std::make_unique<ConvertArithToSPIRVPass>();
}
-add_mlir_conversion_library(MLIRArithmeticToSPIRV
- ArithmeticToSPIRV.cpp
+add_mlir_conversion_library(MLIRArithToSPIRV
+ ArithToSPIRV.cpp
ADDITIONAL_HEADER_DIRS
- ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/ArithmeticToSPIRV
+ ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/ArithToSPIRV
DEPENDS
MLIRConversionPassIncGen
Core
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRFuncToSPIRV
MLIRSPIRVConversion
MLIRSPIRVDialect
Core
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRArmNeonDialect
MLIRPass
MLIRTransforms
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Async/IR/Async.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Func/Transforms/FuncConversions.h"
Core
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRAsyncDialect
MLIRFuncToLLVM
MLIRFuncTransforms
#include "mlir/Conversion/BufferizationToMemRef/BufferizationToMemRef.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/BuiltinTypes.h"
add_subdirectory(AffineToStandard)
add_subdirectory(AMDGPUToROCDL)
-add_subdirectory(ArithmeticToLLVM)
-add_subdirectory(ArithmeticToSPIRV)
+add_subdirectory(ArithToLLVM)
+add_subdirectory(ArithToSPIRV)
add_subdirectory(ArmNeon2dToIntr)
add_subdirectory(AsyncToLLVM)
add_subdirectory(BufferizationToMemRef)
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Pass/Pass.h"
MLIRConversionPassIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRComplexDialect
MLIRIR
MLIRMathDialect
#include "mlir/Conversion/ComplexToStandard/ComplexToStandard.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/IR/ImplicitLocOpBuilder.h"
populateComplexToStandardConversionPatterns(patterns);
ConversionTarget target(getContext());
- target.addLegalDialect<arith::ArithmeticDialect, math::MathDialect>();
+ target.addLegalDialect<arith::ArithDialect, math::MathDialect>();
target.addLegalOp<complex::CreateOp, complex::ImOp, complex::ReOp>();
if (failed(
applyPartialConversion(getOperation(), target, std::move(patterns))))
LINK_LIBS PUBLIC
MLIRAnalysis
- MLIRArithmeticToLLVM
+ MLIRArithToLLVM
MLIRControlFlowToLLVM
MLIRDataLayoutInterfaces
MLIRFuncDialect
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Analysis/DataLayoutAnalysis.h"
-#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
+#include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
populateFuncToLLVMConversionPatterns(typeConverter, patterns);
// TODO: Remove these in favor of their dedicated conversion passes.
- arith::populateArithmeticToLLVMConversionPatterns(typeConverter, patterns);
+ arith::populateArithToLLVMConversionPatterns(typeConverter, patterns);
cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns);
LLVMConversionTarget target(getContext());
${NVPTX_LIBS}
LINK_LIBS PUBLIC
- MLIRArithmeticToLLVM
+ MLIRArithToLLVM
MLIRAsyncToLLVM
MLIRControlFlowToLLVM
MLIRFuncToLLVM
#include "mlir/Conversion/GPUCommon/GPUCommonPass.h"
-#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
+#include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
target.addIllegalDialect<gpu::GPUDialect>();
- mlir::arith::populateArithmeticToLLVMConversionPatterns(converter, patterns);
+ mlir::arith::populateArithToLLVMConversionPatterns(converter, patterns);
mlir::cf::populateControlFlowToLLVMConversionPatterns(converter, patterns);
populateVectorToLLVMConversionPatterns(converter, patterns);
populateMemRefToLLVMConversionPatterns(converter, patterns);
MLIRGPUToNVVMIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticToLLVM
+ MLIRArithToLLVM
MLIRFuncToLLVM
MLIRGPUOps
MLIRGPUToGPURuntimeTransforms
#include "mlir/Conversion/GPUToNVVM/GPUToNVVMPass.h"
-#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
+#include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/LoweringOptions.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlow.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
populateGpuRewritePatterns(patterns);
(void)applyPatternsAndFoldGreedily(m, std::move(patterns));
- arith::populateArithmeticToLLVMConversionPatterns(converter, llvmPatterns);
+ arith::populateArithToLLVMConversionPatterns(converter, llvmPatterns);
cf::populateControlFlowToLLVMConversionPatterns(converter, llvmPatterns);
populateFuncToLLVMConversionPatterns(converter, llvmPatterns);
populateMemRefToLLVMConversionPatterns(converter, llvmPatterns);
MLIRGPUToROCDLIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticToLLVM
+ MLIRArithToLLVM
MLIRAMDGPUToROCDL
MLIRFuncToLLVM
MLIRGPUOps
#include "mlir/Conversion/GPUToROCDL/GPUToROCDLPass.h"
#include "mlir/Conversion/AMDGPUToROCDL/AMDGPUToROCDL.h"
-#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
+#include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/LoweringOptions.h"
populateGpuRewritePatterns(patterns);
(void)applyPatternsAndFoldGreedily(m, std::move(patterns));
- mlir::arith::populateArithmeticToLLVMConversionPatterns(converter,
- llvmPatterns);
+ mlir::arith::populateArithToLLVMConversionPatterns(converter, llvmPatterns);
populateAMDGPUToROCDLConversionPatterns(converter, llvmPatterns,
*maybeChipset);
populateVectorToLLVMConversionPatterns(converter, llvmPatterns);
MLIRConversionPassIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticToSPIRV
+ MLIRArithToSPIRV
MLIRGPUOps
MLIRFuncToSPIRV
MLIRIR
#include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h"
-#include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h"
+#include "mlir/Conversion/ArithToSPIRV/ArithToSPIRV.h"
#include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h"
#include "mlir/Conversion/GPUToSPIRV/GPUToSPIRV.h"
#include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRV.h"
// TODO: Change SPIR-V conversion to be progressive and remove the following
// patterns.
- mlir::arith::populateArithmeticToSPIRVPatterns(typeConverter, patterns);
+ mlir::arith::populateArithToSPIRVPatterns(typeConverter, patterns);
populateMemRefToSPIRVPatterns(typeConverter, patterns);
populateFuncToSPIRVPatterns(typeConverter, patterns);
void ConvertLinalgToStandardPass::runOnOperation() {
auto module = getOperation();
ConversionTarget target(getContext());
- target.addLegalDialect<AffineDialect, arith::ArithmeticDialect,
- func::FuncDialect, memref::MemRefDialect,
- scf::SCFDialect>();
+ target.addLegalDialect<AffineDialect, arith::ArithDialect, func::FuncDialect,
+ memref::MemRefDialect, scf::SCFDialect>();
target.addLegalOp<ModuleOp, func::FuncOp, func::ReturnOp>();
RewritePatternSet patterns(&getContext());
populateLinalgToStandardConversionPatterns(patterns);
Core
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRControlFlowDialect
MLIRFuncDialect
MLIRLLVMDialect
#include "mlir/Conversion/MathToFuncs/MathToFuncs.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
patterns.add<IPowIOpLowering>(patterns.getContext(), getPowerFuncOpByType);
ConversionTarget target(getContext());
- target.addLegalDialect<arith::ArithmeticDialect, cf::ControlFlowDialect,
+ target.addLegalDialect<arith::ArithDialect, cf::ControlFlowDialect,
func::FuncDialect, vector::VectorDialect>();
target.addIllegalOp<math::IPowIOp>();
if (failed(applyPartialConversion(module, target, std::move(patterns))))
Core
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRDialectUtils
MLIRFuncDialect
MLIRMathDialect
#include "mlir/Conversion/MathToLibm/MathToLibm.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/Math/IR/Math.h"
populateMathToLibmConversionPatterns(patterns, /*benefit=*/1);
ConversionTarget target(getContext());
- target.addLegalDialect<arith::ArithmeticDialect, BuiltinDialect,
- func::FuncDialect, vector::VectorDialect>();
+ target.addLegalDialect<arith::ArithDialect, BuiltinDialect, func::FuncDialect,
+ vector::VectorDialect>();
target.addIllegalDialect<math::MathDialect>();
if (failed(applyPartialConversion(module, target, std::move(patterns))))
signalPassFailure();
#include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Conversion/MemRefToLLVM/AllocLikeConversion.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/FunctionCallUtils.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
MLIRConversionPassIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRIR
MLIROpenACCDialect
MLIRSCFDialect
#include "mlir/Conversion/OpenACCToSCF/ConvertOpenACCToSCF.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/OpenACC/OpenACC.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Pass/Pass.h"
Core
LINK_LIBS PUBLIC
- MLIRArithmeticToLLVM
+ MLIRArithToLLVM
MLIRFuncToLLVM
MLIRIR
MLIRLLVMCommonConversion
#include "mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h"
-#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
+#include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
// Convert to OpenMP operations with LLVM IR dialect
RewritePatternSet patterns(&getContext());
LLVMTypeConverter converter(&getContext());
- arith::populateArithmeticToLLVMConversionPatterns(converter, patterns);
+ arith::populateArithToLLVMConversionPatterns(converter, patterns);
cf::populateControlFlowToLLVMConversionPatterns(converter, patterns);
populateMemRefToLLVMConversionPatterns(converter, patterns);
populateFuncToLLVMConversionPatterns(converter, patterns);
Core
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRControlFlowDialect
MLIRSCFDialect
MLIRTransforms
#include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/IR/BlockAndValueMapping.h"
LINK_LIBS PUBLIC
MLIRAffineDialect
MLIRAffineToStandard
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRComplexDialect
MLIRGPUTransforms
MLIRIR
#include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/GPU/Transforms/ParallelLoopMapper.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Conversion/SCFToGPU/SCFToGPU.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
LINK_LIBS PUBLIC
MLIRAnalysis
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRLLVMDialect
MLIROpenMPDialect
MLIRSCFDialect
#include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/OpenMP/OpenMPDialect.h"
MLIRConversionPassIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticToSPIRV
+ MLIRArithToSPIRV
MLIRFuncToSPIRV
MLIRMemRefToSPIRV
MLIRSPIRVDialect
#include "mlir/Conversion/SCFToSPIRV/SCFToSPIRVPass.h"
-#include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h"
+#include "mlir/Conversion/ArithToSPIRV/ArithToSPIRV.h"
#include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h"
#include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRV.h"
#include "mlir/Conversion/SCFToSPIRV/SCFToSPIRV.h"
// TODO: Change SPIR-V conversion to be progressive and remove the following
// patterns.
- mlir::arith::populateArithmeticToSPIRVPatterns(typeConverter, patterns);
+ mlir::arith::populateArithToSPIRVPatterns(typeConverter, patterns);
populateFuncToSPIRVPatterns(typeConverter, patterns);
populateMemRefToSPIRVPatterns(typeConverter, patterns);
populateBuiltinFuncToSPIRVPatterns(typeConverter, patterns);
intrinsics_gen
LINK_LIBS PUBLIC
- MLIRArithmeticToLLVM
+ MLIRArithToLLVM
MLIRFuncToLLVM
MLIRGPUOps
MLIRIR
#include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h"
-#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
+#include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/LLVMCommon/LoweringOptions.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h"
auto *context = module.getContext();
RewritePatternSet patterns(context);
LLVMTypeConverter typeConverter(context, options);
- mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter,
- patterns);
+ mlir::arith::populateArithToLLVMConversionPatterns(typeConverter, patterns);
populateMemRefToLLVMConversionPatterns(typeConverter, patterns);
populateFuncToLLVMConversionPatterns(typeConverter, patterns);
patterns.add<GPULaunchLowering>(typeConverter);
Core
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRIR
MLIRShapeDialect
MLIRTensorDialect
#include "mlir/Conversion/ShapeToStandard/ShapeToStandard.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Shape/IR/Shape.h"
// Setup target legality.
MLIRContext &ctx = getContext();
ConversionTarget target(ctx);
- target.addLegalDialect<arith::ArithmeticDialect, SCFDialect,
+ target.addLegalDialect<arith::ArithDialect, SCFDialect,
tensor::TensorDialect>();
target.addLegalOp<CstrRequireOp, func::FuncOp, ModuleOp>();
#include "mlir/Conversion/TensorToLinalg/TensorToLinalgPass.h"
#include "mlir/Conversion/TensorToLinalg/TensorToLinalg.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
void runOnOperation() override {
auto &context = getContext();
ConversionTarget target(context);
- target.addLegalDialect<mlir::arith::ArithmeticDialect,
- mlir::linalg::LinalgDialect,
- mlir::tensor::TensorDialect>();
+ target
+ .addLegalDialect<mlir::arith::ArithDialect, mlir::linalg::LinalgDialect,
+ mlir::tensor::TensorDialect>();
target.addIllegalOp<mlir::tensor::PadOp>();
RewritePatternSet patterns(&context);
MLIRConversionPassIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticToSPIRV
+ MLIRArithToSPIRV
MLIRFuncToSPIRV
MLIRIR
MLIRPass
#include "mlir/Conversion/TensorToSPIRV/TensorToSPIRVPass.h"
-#include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h"
+#include "mlir/Conversion/ArithToSPIRV/ArithToSPIRV.h"
#include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h"
#include "mlir/Conversion/TensorToSPIRV/TensorToSPIRV.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
SPIRVTypeConverter typeConverter(targetAttr, options);
RewritePatternSet patterns(context);
- arith::populateArithmeticToSPIRVPatterns(typeConverter, patterns);
+ arith::populateArithToSPIRVPatterns(typeConverter, patterns);
populateFuncToSPIRVPatterns(typeConverter, patterns);
populateTensorToSPIRVPatterns(typeConverter, /*byteCountThreshold=*/64,
patterns);
MLIRConversionPassIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRIR
MLIRPass
MLIRTosaDialect
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/TosaToArith/TosaToArith.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/IR/TypeUtilities.h"
#include "mlir/Conversion/TosaToArith/TosaToArith.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h"
#include "mlir/Dialect/Tosa/Transforms/Passes.h"
#include "mlir/IR/PatternMatch.h"
RewritePatternSet patterns(&getContext());
ConversionTarget target(getContext());
target.addIllegalOp<tosa::ConstOp>();
- target.addLegalDialect<arith::ArithmeticDialect>();
+ target.addLegalDialect<arith::ArithDialect>();
mlir::tosa::populateTosaToArithConversionPatterns(&patterns);
MLIRConversionPassIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRDialectUtils
MLIRIR
MLIRLinalgDialect
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Math/IR/Math.h"
public:
void getDependentDialects(DialectRegistry ®istry) const override {
registry
- .insert<arith::ArithmeticDialect, linalg::LinalgDialect,
- math::MathDialect, tensor::TensorDialect, scf::SCFDialect>();
+ .insert<arith::ArithDialect, linalg::LinalgDialect, math::MathDialect,
+ tensor::TensorDialect, scf::SCFDialect>();
}
void runOnOperation() override {
#include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Math/IR/Math.h"
public:
void getDependentDialects(DialectRegistry ®istry) const override {
registry
- .insert<arith::ArithmeticDialect, linalg::LinalgDialect,
- math::MathDialect, tensor::TensorDialect, scf::SCFDialect>();
+ .insert<arith::ArithDialect, linalg::LinalgDialect, math::MathDialect,
+ tensor::TensorDialect, scf::SCFDialect>();
}
void runOnOperation() override {
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/TosaToTensor/TosaToTensor.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/Conversion/TosaToTensor/TosaToTensor.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h"
#include "mlir/Dialect/Tosa/Transforms/Passes.h"
RewritePatternSet patterns(&getContext());
ConversionTarget target(getContext());
target.addIllegalOp<tosa::SliceOp>();
- target.addLegalDialect<arith::ArithmeticDialect>();
+ target.addLegalDialect<arith::ArithDialect>();
target.addLegalDialect<tensor::TensorDialect>();
mlir::tosa::populateTosaToTensorConversionPatterns(&patterns);
Core
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRGPUOps
MLIRLLVMDialect
MLIRMemRefDialect
//===----------------------------------------------------------------------===//
#include "NvGpuSupport.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Conversion/VectorToGPU/VectorToGPU.h"
#include "mlir/Analysis/SliceAnalysis.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h"
Core
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRArmNeonDialect
MLIRArmSVEDialect
MLIRArmSVETransforms
#include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
#include "mlir/Conversion/LLVMCommon/VectorPattern.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/LLVMIR/FunctionCallUtils.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Dialect/AMX/AMXDialect.h"
#include "mlir/Dialect/AMX/Transforms.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/ArmNeon/ArmNeonDialect.h"
#include "mlir/Dialect/ArmSVE/ArmSVEDialect.h"
#include "mlir/Dialect/ArmSVE/Transforms.h"
// Override explicitly to allow conditional dialect dependence.
void getDependentDialects(DialectRegistry ®istry) const override {
registry.insert<LLVM::LLVMDialect>();
- registry.insert<arith::ArithmeticDialect>();
+ registry.insert<arith::ArithDialect>();
registry.insert<memref::MemRefDialect>();
if (armNeon)
registry.insert<arm_neon::ArmNeonDialect>();
// Architecture specific augmentations.
LLVMConversionTarget target(getContext());
- target.addLegalDialect<arith::ArithmeticDialect>();
+ target.addLegalDialect<arith::ArithDialect>();
target.addLegalDialect<memref::MemRefDialect>();
target.addLegalOp<UnrealizedConversionCastOp>();
if (armNeon) {
Core
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRLLVMDialect
MLIRMemRefDialect
MLIRTransforms
#include "mlir/Conversion/VectorToSCF/VectorToSCF.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Vector/Transforms/VectorTransforms.h"
#include "mlir/Analysis/Presburger/Utils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/IR/AffineValueMap.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/AffineExprVisitor.h"
#include "mlir/IR/IntegerSet.h"
#include "mlir/Support/LLVM.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/IR/AffineValueMap.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/IntegerSet.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/Support/Debug.h"
MLIRAffineOpsIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRDialectUtils
MLIRIR
MLIRLoopLikeInterface
#include "mlir/Dialect/Affine/Analysis/Utils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Affine/Utils.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h"
MLIRAffineDialect
MLIRAffineAnalysis
MLIRAffineUtils
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRIR
MLIRMemRefDialect
MLIRPass
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Utils/Utils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Affine/Utils.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/Builders.h"
#include "mlir/Dialect/Affine/Analysis/NestedMatcher.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/Utils.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/Vector/Utils/VectorUtils.h"
MLIRAffineDialect
MLIRAffineAnalysis
MLIRAnalysis
- MLIRArithmeticUtils
+ MLIRArithUtils
MLIRMemRefDialect
MLIRTransformUtils
MLIRViewLikeInterface
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/IR/AffineValueMap.h"
#include "mlir/Dialect/Affine/LoopUtils.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/AffineExprVisitor.h"
-//===- ArithmeticPatterns.td - Arithmetic dialect patterns -*- tablegen -*-===//
+//===- ArithPatterns.td - Arith dialect patterns -*- tablegen -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
//
//===----------------------------------------------------------------------===//
-#ifndef ARITHMETIC_PATTERNS
-#define ARITHMETIC_PATTERNS
+#ifndef ARITH_PATTERNS
+#define ARITH_PATTERNS
include "mlir/IR/PatternBase.td"
-include "mlir/Dialect/Arithmetic/IR/ArithmeticOps.td"
+include "mlir/Dialect/Arith/IR/ArithOps.td"
// Create zero attribute of type matching the argument's type.
def GetZeroAttr : NativeCodeCall<"$_builder.getZeroAttr($0.getType())">;
Pat<(Arith_DivFOp (Arith_NegFOp $x), (Arith_NegFOp $y)), (Arith_DivFOp $x, $y),
[(Constraint<CPred<"$0.getType() == $1.getType()">> $x, $y)]>;
-#endif // ARITHMETIC_PATTERNS
+#endif // ARITH_PATTERNS
-//===- ArithmeticDialect.cpp - MLIR Arithmetic dialect implementation -----===//
+//===- ArithDialect.cpp - MLIR Arith dialect implementation -----===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/Builders.h"
#include "mlir/Transforms/InliningUtils.h"
using namespace mlir;
using namespace mlir::arith;
-#include "mlir/Dialect/Arithmetic/IR/ArithmeticOpsDialect.cpp.inc"
+#include "mlir/Dialect/Arith/IR/ArithOpsDialect.cpp.inc"
namespace {
/// This class defines the interface for handling inlining for arithmetic
/// dialect operations.
-struct ArithmeticInlinerInterface : public DialectInlinerInterface {
+struct ArithInlinerInterface : public DialectInlinerInterface {
using DialectInlinerInterface::DialectInlinerInterface;
/// All arithmetic dialect ops can be inlined.
};
} // namespace
-void arith::ArithmeticDialect::initialize() {
+void arith::ArithDialect::initialize() {
addOperations<
#define GET_OP_LIST
-#include "mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
+#include "mlir/Dialect/Arith/IR/ArithOps.cpp.inc"
>();
- addInterfaces<ArithmeticInlinerInterface>();
+ addInterfaces<ArithInlinerInterface>();
}
/// Materialize an integer or floating point constant.
-Operation *arith::ArithmeticDialect::materializeConstant(OpBuilder &builder,
- Attribute value,
- Type type,
- Location loc) {
+Operation *arith::ArithDialect::materializeConstant(OpBuilder &builder,
+ Attribute value, Type type,
+ Location loc) {
return builder.create<arith::ConstantOp>(loc, value, type);
}
-//===- ArithmeticOps.cpp - MLIR Arithmetic dialect ops implementation -----===//
+//===- ArithOps.cpp - MLIR Arith dialect ops implementation -----===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
#include <cassert>
#include <utility>
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/CommonFolders.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/Matchers.h"
//===----------------------------------------------------------------------===//
namespace {
-#include "ArithmeticCanonicalization.inc"
+#include "ArithCanonicalization.inc"
} // namespace
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
#define GET_OP_CLASSES
-#include "mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
+#include "mlir/Dialect/Arith/IR/ArithOps.cpp.inc"
//===----------------------------------------------------------------------===//
// TableGen'd enum attribute definitions
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/ArithmeticOpsEnums.cpp.inc"
+#include "mlir/Dialect/Arith/IR/ArithOpsEnums.cpp.inc"
--- /dev/null
+set(LLVM_TARGET_DEFINITIONS ArithCanonicalization.td)
+mlir_tablegen(ArithCanonicalization.inc -gen-rewriters)
+add_public_tablegen_target(MLIRArithCanonicalizationIncGen)
+
+add_mlir_dialect_library(MLIRArithDialect
+ ArithOps.cpp
+ ArithDialect.cpp
+ InferIntRangeInterfaceImpls.cpp
+
+ ADDITIONAL_HEADER_DIRS
+ ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Arith
+
+ DEPENDS
+ MLIRArithOpsIncGen
+
+ LINK_LIBS PUBLIC
+ MLIRDialect
+ MLIRInferIntRangeInterface
+ MLIRInferTypeOpInterface
+ MLIRIR
+ )
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Interfaces/InferIntRangeInterface.h"
#include "llvm/Support/Debug.h"
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/Transforms/BufferizableOpInterfaceImpl.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/Transforms/BufferizableOpInterfaceImpl.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/Transforms/BufferUtils.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
void mlir::arith::registerBufferizableOpInterfaceExternalModels(
DialectRegistry ®istry) {
- registry.addExtension(+[](MLIRContext *ctx, ArithmeticDialect *dialect) {
+ registry.addExtension(+[](MLIRContext *ctx, ArithDialect *dialect) {
ConstantOp::attachInterface<ConstantOpInterface>(*ctx);
IndexCastOp::attachInterface<IndexCastOpInterface>(*ctx);
SelectOp::attachInterface<SelectOpInterface>(*ctx);
-//===- Bufferize.cpp - Bufferization for Arithmetic ops ---------*- C++ -*-===//
+//===- Bufferize.cpp - Bufferization for Arith ops ---------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
+#include "mlir/Dialect/Arith/Transforms/Passes.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Transforms/BufferizableOpInterfaceImpl.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Arith/Transforms/BufferizableOpInterfaceImpl.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
namespace mlir {
namespace arith {
-#define GEN_PASS_DEF_ARITHMETICBUFFERIZE
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
+#define GEN_PASS_DEF_ARITHBUFFERIZE
+#include "mlir/Dialect/Arith/Transforms/Passes.h.inc"
} // namespace arith
} // namespace mlir
using namespace bufferization;
namespace {
-/// Pass to bufferize Arithmetic ops.
-struct ArithmeticBufferizePass
- : public arith::impl::ArithmeticBufferizeBase<ArithmeticBufferizePass> {
- ArithmeticBufferizePass(uint64_t alignment = 0, bool constantOpOnly = false)
+/// Pass to bufferize Arith ops.
+struct ArithBufferizePass
+ : public arith::impl::ArithBufferizeBase<ArithBufferizePass> {
+ ArithBufferizePass(uint64_t alignment = 0, bool constantOpOnly = false)
: constantOpOnly(constantOpOnly) {
this->alignment = alignment;
}
if (constantOpOnly) {
options.opFilter.allowOperation<arith::ConstantOp>();
} else {
- options.opFilter.allowDialect<arith::ArithmeticDialect>();
+ options.opFilter.allowDialect<arith::ArithDialect>();
}
options.bufferAlignment = alignment;
void getDependentDialects(DialectRegistry ®istry) const override {
registry.insert<bufferization::BufferizationDialect, memref::MemRefDialect,
- arith::ArithmeticDialect>();
+ arith::ArithDialect>();
arith::registerBufferizableOpInterfaceExternalModels(registry);
}
};
} // namespace
-std::unique_ptr<Pass> mlir::arith::createArithmeticBufferizePass() {
- return std::make_unique<ArithmeticBufferizePass>();
+std::unique_ptr<Pass> mlir::arith::createArithBufferizePass() {
+ return std::make_unique<ArithBufferizePass>();
}
std::unique_ptr<Pass>
mlir::arith::createConstantBufferizePass(uint64_t alignment) {
- return std::make_unique<ArithmeticBufferizePass>(alignment,
- /*constantOpOnly=*/true);
+ return std::make_unique<ArithBufferizePass>(alignment,
+ /*constantOpOnly=*/true);
}
-add_mlir_dialect_library(MLIRArithmeticTransforms
+add_mlir_dialect_library(MLIRArithTransforms
BufferizableOpInterfaceImpl.cpp
Bufferize.cpp
EmulateWideInt.cpp
UnsignedWhenEquivalent.cpp
ADDITIONAL_HEADER_DIRS
- {$MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Arithmetic/Transforms
+ {$MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Arith/Transforms
DEPENDS
- MLIRArithmeticTransformsIncGen
+ MLIRArithTransformsIncGen
LINK_LIBS PUBLIC
MLIRAnalysis
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRBufferizationDialect
MLIRBufferizationTransforms
MLIRFuncDialect
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
+#include "mlir/Dialect/Arith/Transforms/Passes.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Transforms/WideIntEmulationConverter.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Arith/Transforms/WideIntEmulationConverter.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Func/Transforms/FuncConversions.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h"
#include <cassert>
namespace mlir::arith {
-#define GEN_PASS_DEF_ARITHMETICEMULATEWIDEINT
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
+#define GEN_PASS_DEF_ARITHEMULATEWIDEINT
+#include "mlir/Dialect/Arith/Transforms/Passes.h.inc"
} // namespace mlir::arith
using namespace mlir;
//===----------------------------------------------------------------------===//
struct EmulateWideIntPass final
- : arith::impl::ArithmeticEmulateWideIntBase<EmulateWideIntPass> {
- using ArithmeticEmulateWideIntBase::ArithmeticEmulateWideIntBase;
+ : arith::impl::ArithEmulateWideIntBase<EmulateWideIntPass> {
+ using ArithEmulateWideIntBase::ArithEmulateWideIntBase;
void runOnOperation() override {
if (!llvm::isPowerOf2_32(widestIntSupported) || widestIntSupported < 2) {
return typeConverter.isLegal(op);
};
target.addDynamicallyLegalOp<func::CallOp, func::ReturnOp>(opLegalCallback);
- target.addDynamicallyLegalDialect<arith::ArithmeticDialect,
- vector::VectorDialect>(opLegalCallback);
+ target
+ .addDynamicallyLegalDialect<arith::ArithDialect, vector::VectorDialect>(
+ opLegalCallback);
RewritePatternSet patterns(ctx);
arith::populateWideIntEmulationPatterns(typeConverter, patterns);
-//===- ExpandOps.cpp - Pass to legalize Arithmetic ops for LLVM lowering --===//
+//===- ExpandOps.cpp - Pass to legalize Arith ops for LLVM lowering --===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
+#include "mlir/Dialect/Arith/Transforms/Passes.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/TypeUtilities.h"
#include "mlir/Transforms/DialectConversion.h"
namespace mlir {
namespace arith {
-#define GEN_PASS_DEF_ARITHMETICEXPANDOPS
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
+#define GEN_PASS_DEF_ARITHEXPANDOPS
+#include "mlir/Dialect/Arith/Transforms/Passes.h.inc"
} // namespace arith
} // namespace mlir
}
};
-struct ArithmeticExpandOpsPass
- : public arith::impl::ArithmeticExpandOpsBase<ArithmeticExpandOpsPass> {
+struct ArithExpandOpsPass
+ : public arith::impl::ArithExpandOpsBase<ArithExpandOpsPass> {
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
ConversionTarget target(getContext());
- arith::populateArithmeticExpandOpsPatterns(patterns);
+ arith::populateArithExpandOpsPatterns(patterns);
- target.addLegalDialect<arith::ArithmeticDialect>();
+ target.addLegalDialect<arith::ArithDialect>();
// clang-format off
target.addIllegalOp<
arith::CeilDivSIOp,
} // namespace
-void mlir::arith::populateArithmeticExpandOpsPatterns(
- RewritePatternSet &patterns) {
+void mlir::arith::populateArithExpandOpsPatterns(RewritePatternSet &patterns) {
// clang-format off
patterns.add<
CeilDivSIOpConverter,
// clang-format on
}
-std::unique_ptr<Pass> mlir::arith::createArithmeticExpandOpsPass() {
- return std::make_unique<ArithmeticExpandOpsPass>();
+std::unique_ptr<Pass> mlir::arith::createArithExpandOpsPass() {
+ return std::make_unique<ArithExpandOpsPass>();
}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
+#include "mlir/Dialect/Arith/Transforms/Passes.h"
#include "mlir/Analysis/DataFlow/DeadCodeAnalysis.h"
#include "mlir/Analysis/DataFlow/IntegerRangeAnalysis.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Transforms/DialectConversion.h"
namespace mlir {
namespace arith {
-#define GEN_PASS_DEF_ARITHMETICUNSIGNEDWHENEQUIVALENT
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
+#define GEN_PASS_DEF_ARITHUNSIGNEDWHENEQUIVALENT
+#include "mlir/Dialect/Arith/Transforms/Passes.h.inc"
} // namespace arith
} // namespace mlir
}
};
-struct ArithmeticUnsignedWhenEquivalentPass
- : public arith::impl::ArithmeticUnsignedWhenEquivalentBase<
- ArithmeticUnsignedWhenEquivalentPass> {
+struct ArithUnsignedWhenEquivalentPass
+ : public arith::impl::ArithUnsignedWhenEquivalentBase<
+ ArithUnsignedWhenEquivalentPass> {
/// Implementation structure: first find all equivalent ops and collect them,
/// then perform all the rewrites in a second pass over the target op. This
/// ensures that analysis results are not invalidated during rewriting.
return signalPassFailure();
ConversionTarget target(*ctx);
- target.addLegalDialect<ArithmeticDialect>();
+ target.addLegalDialect<ArithDialect>();
target
.addDynamicallyLegalOp<DivSIOp, CeilDivSIOp, CeilDivUIOp, FloorDivSIOp,
RemSIOp, MinSIOp, MaxSIOp, ExtSIOp>(
};
} // end anonymous namespace
-std::unique_ptr<Pass>
-mlir::arith::createArithmeticUnsignedWhenEquivalentPass() {
- return std::make_unique<ArithmeticUnsignedWhenEquivalentPass>();
+std::unique_ptr<Pass> mlir::arith::createArithUnsignedWhenEquivalentPass() {
+ return std::make_unique<ArithUnsignedWhenEquivalentPass>();
}
--- /dev/null
+add_mlir_dialect_library(MLIRArithUtils
+ Utils.cpp
+
+ ADDITIONAL_HEADER_DIRS
+ ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Arith/Utils
+
+ LINK_LIBS PUBLIC
+ MLIRArithDialect
+ MLIRDialect
+ MLIRIR
+ )
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "llvm/ADT/SmallBitVector.h"
using namespace mlir;
+++ /dev/null
-set(LLVM_TARGET_DEFINITIONS ArithmeticCanonicalization.td)
-mlir_tablegen(ArithmeticCanonicalization.inc -gen-rewriters)
-add_public_tablegen_target(MLIRArithmeticCanonicalizationIncGen)
-
-add_mlir_dialect_library(MLIRArithmeticDialect
- ArithmeticOps.cpp
- ArithmeticDialect.cpp
- InferIntRangeInterfaceImpls.cpp
-
- ADDITIONAL_HEADER_DIRS
- ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Arithmetic
-
- DEPENDS
- MLIRArithmeticOpsIncGen
-
- LINK_LIBS PUBLIC
- MLIRDialect
- MLIRInferIntRangeInterface
- MLIRInferTypeOpInterface
- MLIRIR
- )
+++ /dev/null
-add_mlir_dialect_library(MLIRArithmeticUtils
- Utils.cpp
-
- ADDITIONAL_HEADER_DIRS
- ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Arithmetic/Utils
-
- LINK_LIBS PUBLIC
- MLIRArithmeticDialect
- MLIRDialect
- MLIRIR
- )
#include "mlir/Dialect/Async/Passes.h"
#include "PassDetail.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Async/IR/Async.h"
#include "mlir/Dialect/Async/Transforms.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "PassDetail.h"
#include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Async/IR/Async.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
MLIRAsyncPassIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRAsyncDialect
MLIRFuncDialect
MLIRIR
namespace mlir {
namespace arith {
-class ArithmeticDialect;
+class ArithDialect;
} // namespace arith
namespace async {
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Bufferization/Transforms/BufferViewFlowAnalysis.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Interfaces/ControlFlowInterfaces.h"
#include "mlir/Interfaces/ViewLikeInterface.h"
#include "llvm/ADT/SetOperations.h"
add_subdirectory(Affine)
add_subdirectory(AMDGPU)
-add_subdirectory(Arithmetic)
+add_subdirectory(Arith)
add_subdirectory(ArmNeon)
add_subdirectory(ArmSVE)
add_subdirectory(Async)
MLIRComplexAttributesIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRDialect
MLIRInferTypeOpInterface
MLIRIR
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/DialectImplementation.h"
MLIRControlFlowOpsIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRControlFlowInterfaces
MLIRIR
MLIRSideEffectInterfaces
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/CommonFolders.h"
#include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h"
MLIRGPUOpInterfacesIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRDLTIDialect
MLIRInferIntRangeInterface
MLIRIR
LINK_LIBS PUBLIC
MLIRAffineUtils
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRAsyncDialect
MLIRDataLayoutInterfaces
MLIRExecutionEngineUtils
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/Attributes.h"
#include "mlir/IR/Builders.h"
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/GPU/Transforms/Passes.h"
#include "mlir/Dialect/GPU/Transforms/Passes.h"
#include "mlir/AsmParser/AsmParser.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/DLTI/DLTI.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/Transforms/MemoryPromotion.h"
#include "mlir/Dialect/Affine/LoopUtils.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
LINK_LIBS PUBLIC
MLIRAffineDialect
- MLIRArithmeticDialect
- MLIRArithmeticUtils
+ MLIRArithDialect
+ MLIRArithUtils
MLIRBufferizationDialect
MLIRDialectUtils
MLIRInferTypeOpInterface
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/Linalg/IR/LinalgInterfaces.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/AsmParser/AsmParser.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
LINK_LIBS PUBLIC
MLIRAffineDialect
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRIR
MLIRLinalgDialect
MLIRLinalgTransforms
#include "mlir/AsmParser/AsmParser.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
declareDependentDialect<pdl::PDLDialect>();
declareDependentDialect<LinalgDialect>();
declareGeneratedDialect<AffineDialect>();
- declareGeneratedDialect<arith::ArithmeticDialect>();
+ declareGeneratedDialect<arith::ArithDialect>();
declareGeneratedDialect<scf::SCFDialect>();
declareGeneratedDialect<vector::VectorDialect>();
declareGeneratedDialect<gpu::GPUDialect>();
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
MLIRAffineDialect
MLIRAffineUtils
MLIRAnalysis
- MLIRArithmeticDialect
- MLIRArithmeticTransforms
- MLIRArithmeticUtils
+ MLIRArithDialect
+ MLIRArithTransforms
+ MLIRArithUtils
MLIRBufferizationDialect
MLIRBufferizationTransforms
MLIRComplexDialect
#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
#include "mlir/Dialect/Linalg/Passes.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h"
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
#include "mlir/Dialect/Affine/IR/AffineValueMap.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Passes.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Passes.h"
#include <utility>
#include "mlir/Analysis/SliceAnalysis.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/TilingInterfaceImpl.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
MLIRAffineDialect
MLIRAffineAnalysis
MLIRAffineUtils
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRFuncDialect
MLIRIR
MLIRLinalgDialect
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/IR/AffineValueMap.h"
#include "mlir/Dialect/Affine/LoopUtils.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
MLIRMathOpsIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRDialect
MLIRIR
)
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/CommonFolders.h"
#include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/IR/Builders.h"
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/Math/Transforms/Passes.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h"
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Math/Transforms
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRDialectUtils
MLIRIR
MLIRMathDialect
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/Math/Transforms/Passes.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include <climits>
#include <cstddef>
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/Math/Transforms/Approximation.h"
#include "mlir/Dialect/Math/Transforms/Passes.h"
Core
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
- MLIRArithmeticUtils
+ MLIRArithDialect
+ MLIRArithUtils
MLIRControlFlowInterfaces
MLIRDialect
MLIRDialectUtils
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Interfaces/SideEffectInterfaces.h"
#include "mlir/Transforms/InliningUtils.h"
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/MemRef/Utils/MemRefUtils.h"
#include "mlir/Dialect/Utils/StaticValueUtils.h"
LINK_LIBS PUBLIC
MLIRAffineDialect
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRIR
MLIRPDLDialect
MLIRMemRefDialect
#include "mlir/Dialect/MemRef/TransformOps/MemRefTransformOps.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/MemRef/Transforms/Passes.h"
#include "mlir/Dialect/PDL/IR/PDL.h"
void init() {
declareDependentDialect<pdl::PDLDialect>();
declareGeneratedDialect<AffineDialect>();
- declareGeneratedDialect<arith::ArithmeticDialect>();
+ declareGeneratedDialect<arith::ArithDialect>();
registerTransformOps<
#define GET_OP_LIST
LINK_LIBS PUBLIC
MLIRAffineDialect
MLIRAffineUtils
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRFuncDialect
MLIRInferTypeOpInterface
MLIRLoopLikeInterface
#include "mlir/Dialect/MemRef/Transforms/Passes.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Arith/Transforms/Passes.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/TypeUtilities.h"
#include "mlir/Transforms/DialectConversion.h"
memref::populateExpandOpsPatterns(patterns);
ConversionTarget target(ctx);
- target.addLegalDialect<arith::ArithmeticDialect, memref::MemRefDialect>();
+ target.addLegalDialect<arith::ArithDialect, memref::MemRefDialect>();
target.addDynamicallyLegalOp<memref::AtomicRMWOp>(
[](memref::AtomicRMWOp op) {
return op.getKind() != arith::AtomicRMWKind::maxf &&
#include "mlir/Dialect/MemRef/Transforms/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Utils/IndexingUtils.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/MemRef/Transforms/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Interfaces/InferTypeOpInterface.h"
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/MemRef/Transforms/Passes.h"
#include "mlir/IR/BuiltinTypes.h"
MLIRNVGPUPassIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRGPUOps
MLIRIR
MLIRMemRefDialect
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h"
#include "mlir/Dialect/NVGPU/Passes.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h"
MLIRSCFOpsIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRBufferizationDialect
MLIRControlFlowDialect
MLIRIR
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/SCF/IR/SCF.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
LINK_LIBS PUBLIC
MLIRAffineDialect
MLIRAffineAnalysis
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRBufferizationDialect
MLIRBufferizationTransforms
MLIRDialectUtils
#include "mlir/Dialect/SCF/Transforms/Passes.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/IR/PatternMatch.h"
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Transforms/Patterns.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/Transforms/Passes.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/Utils/Utils.h"
#include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/Utils/AffineCanonicalizationUtils.h"
#include "mlir/Dialect/SCF/Transforms/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/Utils/Utils.h"
#include "mlir/Dialect/SCF/Transforms/TileUsingInterface.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SCF/Utils/Utils.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
MLIRAffineDialect
MLIRAffineAnalysis
MLIRAnalysis
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRDialectUtils
MLIRFuncDialect
MLIRIR
#include "mlir/Dialect/SCF/Utils/Utils.h"
#include "mlir/Analysis/SliceAnalysis.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/IR/BlockAndValueMapping.h"
MLIRShapeOpsIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRCallInterfaces
MLIRCastInterfaces
MLIRControlFlowInterfaces
#include "mlir/Dialect/Shape/IR/Shape.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/CommonFolders.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Traits.h"
target_link_libraries(MLIRShapeOpsTransforms
PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRBufferizationDialect
MLIRBufferizationTransforms
MLIRIR
#include "mlir/Dialect/Shape/Transforms/Passes.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Shape/IR/Shape.h"
#include "mlir/IR/Builders.h"
populateShapeRewritePatterns(patterns);
ConversionTarget target(getContext());
- target.addLegalDialect<arith::ArithmeticDialect, ShapeDialect>();
+ target.addLegalDialect<arith::ArithDialect, ShapeDialect>();
target.addIllegalOp<NumElementsOp>();
if (failed(mlir::applyPartialConversion(getOperation(), target,
std::move(patterns))))
MLIRSparseTensorOpsIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRDialect
MLIRIR
MLIRInferTypeOpInterface
#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/DialectImplementation.h"
#include "mlir/IR/Matchers.h"
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SparseTensor
LINK_LIBS PUBLIC
- MLIRArithmeticTransforms
+ MLIRArithTransforms
MLIRAffineToStandard
MLIRBufferizationTransforms
MLIRComplexToLLVM
#include "mlir/Dialect/SparseTensor/Pipelines/Passes.h"
#include "mlir/Conversion/Passes.h"
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
+#include "mlir/Dialect/Arith/Transforms/Passes.h"
#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
#include "mlir/Dialect/Bufferization/Transforms/OneShotAnalysis.h"
#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
pm.addPass(createConvertVectorToLLVMPass(options.lowerVectorToLLVMOptions()));
pm.addPass(createMemRefToLLVMConversionPass());
pm.addNestedPass<func::FuncOp>(createConvertComplexToStandardPass());
- pm.addNestedPass<mlir::func::FuncOp>(
- mlir::arith::createArithmeticExpandOpsPass());
+ pm.addNestedPass<mlir::func::FuncOp>(mlir::arith::createArithExpandOpsPass());
pm.addNestedPass<func::FuncOp>(createConvertMathToLLVMPass());
pm.addPass(createConvertMathToLibmPass());
pm.addPass(createConvertComplexToLibmPass());
MLIRSparseTensorPassIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRBufferizationDialect
MLIRBufferizationTransforms
MLIRComplexDialect
#ifndef MLIR_DIALECT_SPARSETENSOR_TRANSFORMS_CODEGENUTILS_H_
#define MLIR_DIALECT_SPARSETENSOR_TRANSFORMS_CODEGENUTILS_H_
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
#include "mlir/ExecutionEngine/SparseTensorUtils.h"
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
target.addLegalOp<complex::ConstantOp, complex::NotEqualOp, linalg::FillOp,
linalg::YieldOp, tensor::ExtractOp>();
target.addLegalDialect<
- arith::ArithmeticDialect, bufferization::BufferizationDialect,
+ arith::ArithDialect, bufferization::BufferizationDialect,
LLVM::LLVMDialect, memref::MemRefDialect, scf::SCFDialect>();
// Translate strategy flags to strategy options.
SparseTensorConversionOptions options(
// The following operations and dialects may be introduced by the
// codegen rules, and are therefore marked as legal.
target.addLegalOp<linalg::FillOp>();
- target.addLegalDialect<arith::ArithmeticDialect,
+ target.addLegalDialect<arith::ArithDialect,
bufferization::BufferizationDialect,
memref::MemRefDialect, scf::SCFDialect>();
target.addLegalOp<UnrealizedConversionCastOp>();
#include "CodegenUtils.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
#include "CodegenUtils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SparseTensor
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRComplexDialect
MLIRIR
MLIRLinalgDialect
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/SparseTensor/Utils/Merger.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
Core
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
- MLIRArithmeticUtils
+ MLIRArithDialect
+ MLIRArithUtils
MLIRCastInterfaces
MLIRComplexDialect
MLIRDialectUtils
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Transforms/InliningUtils.h"
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Utils/ReshapeOpsUtils.h"
#include "mlir/Dialect/Tensor/IR/TensorTilingInterfaceImpl.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tensor/Transforms/BufferizableOpInterfaceImpl.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
ReshapeOp::attachInterface<ReshapeOpInterface>(*ctx);
// Load additional dialects of which ops may get created.
- ctx->loadDialect<arith::ArithmeticDialect, scf::SCFDialect>();
+ ctx->loadDialect<arith::ArithDialect, scf::SCFDialect>();
});
}
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
}
void getDependentDialects(DialectRegistry ®istry) const override {
- registry.insert<bufferization::BufferizationDialect, memref::MemRefDialect,
- tensor::TensorDialect, scf::SCFDialect,
- arith::ArithmeticDialect>();
+ registry
+ .insert<bufferization::BufferizationDialect, memref::MemRefDialect,
+ tensor::TensorDialect, scf::SCFDialect, arith::ArithDialect>();
tensor::registerBufferizableOpInterfaceExternalModels(registry);
}
};
LINK_LIBS PUBLIC
MLIRAffineDialect
MLIRAffineUtils
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRBufferizationDialect
MLIRBufferizationTransforms
MLIRIR
//
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tensor/Transforms/TransformUtils.h"
#include "mlir/Dialect/Tensor/Transforms/Transforms.h"
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tensor/Transforms/Transforms.h"
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tensor/Transforms/Transforms.h"
#include "mlir/Dialect/Utils/StaticValueUtils.h"
LINK_LIBS PUBLIC
MLIRAffineDialect
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRIR
MLIRTensorDialect
)
#include "mlir/Dialect/Tensor/Utils/Utils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
using namespace mlir;
using namespace mlir::tensor;
StaticValueUtils.cpp
LINK_LIBS PUBLIC
- MLIRArithmeticUtils
+ MLIRArithUtils
MLIRIR
)
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/Utils/StaticValueUtils.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/IR/Matchers.h"
#include "mlir/Support/LLVM.h"
#include "llvm/ADT/APSInt.h"
MLIRVectorOpsEnumsIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRControlFlowInterfaces
MLIRDataLayoutInterfaces
MLIRDialectUtils
#include "mlir/Dialect/Vector/IR/VectorOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Utils/IndexingUtils.h"
MLIRAffineDialect
MLIRAffineAnalysis
MLIRAffineUtils
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRBufferizationDialect
MLIRBufferizationTransforms
MLIRDialectUtils
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h"
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Utils/IndexingUtils.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h"
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Vector/Transforms/VectorRewritePatterns.h"
#include "mlir/Dialect/Vector/Utils/VectorUtils.h"
#include "mlir/IR/Builders.h"
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/Vector/Transforms/VectorTransforms.h"
#include <type_traits>
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include <type_traits>
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Arith/Utils/Utils.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
LINK_LIBS PUBLIC
MLIRAffineDialect
MLIRAffineAnalysis
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRDialectUtils
MLIRFuncDialect
MLIRIR
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/X86Vector/Transforms.h"
MLIRX86VectorConversionsIncGen
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRX86VectorDialect
MLIRIR
MLIRLLVMCommonConversion
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/X86Vector/X86VectorDialect.h"
#include "mlir/IR/BuiltinOps.h"
${EMITC_MAIN_INCLUDE_DIR}/emitc/Target/Cpp
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRControlFlowDialect
MLIREmitCDialect
MLIRFuncDialect
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlow.h"
#include "mlir/Dialect/EmitC/IR/EmitC.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
},
[](DialectRegistry ®istry) {
// clang-format off
- registry.insert<arith::ArithmeticDialect,
+ registry.insert<arith::ArithDialect,
cf::ControlFlowDialect,
emitc::EmitCDialect,
func::FuncDialect,
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/EmitC/IR/EmitC.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
declare_mlir_dialect_python_bindings(
ADD_TO_PARENT MLIRPythonSources.Dialects
ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/mlir"
- TD_FILE dialects/ArithmeticOps.td
+ TD_FILE dialects/ArithOps.td
SOURCES
dialects/arith.py
dialects/_arith_ops_ext.py
-//===-- ArithmeticOps.td - Entry point for ArithmeticOps bindings ---------===//
+//===-- ArithOps.td - Entry point for ArithOps bindings ---------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
//
//===----------------------------------------------------------------------===//
-#ifndef PYTHON_BINDINGS_ARITHMETIC_OPS
-#define PYTHON_BINDINGS_ARITHMETIC_OPS
+#ifndef PYTHON_BINDINGS_ARITH_OPS
+#define PYTHON_BINDINGS_ARITH_OPS
include "mlir/Bindings/Python/Attributes.td"
-include "mlir/Dialect/Arithmetic/IR/ArithmeticOps.td"
+include "mlir/Dialect/Arith/IR/ArithOps.td"
#endif
pm, mlirStringRefCreateFromCString("func.func"));
mlirPassManagerAddOwnedPass(pm, mlirCreateConversionConvertFuncToLLVM());
mlirOpPassManagerAddOwnedPass(
- opm, mlirCreateConversionArithmeticToLLVMConversionPass());
+ opm, mlirCreateConversionArithToLLVMConversionPass());
MlirLogicalResult status = mlirPassManagerRun(pm, module);
if (mlirLogicalResultIsFailure(status)) {
fprintf(stderr, "Unexpected failure running pass pipeline\n");
# Exclude tests from libMLIR.so
-add_mlir_library(MLIRArithmeticTestPasses
+add_mlir_library(MLIRArithTestPasses
TestEmulateWideInt.cpp
EXCLUDE_FROM_LIBMLIR
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
- MLIRArithmeticTransforms
+ MLIRArithDialect
+ MLIRArithTransforms
MLIRFuncDialect
MLIRLLVMDialect
MLIRPass
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
-#include "mlir/Dialect/Arithmetic/Transforms/WideIntEmulationConverter.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Arith/Transforms/Passes.h"
+#include "mlir/Dialect/Arith/Transforms/WideIntEmulationConverter.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h"
: PassWrapper(pass) {}
void getDependentDialects(DialectRegistry ®istry) const override {
- registry.insert<arith::ArithmeticDialect, func::FuncDialect,
- LLVM::LLVMDialect, vector::VectorDialect>();
+ registry.insert<arith::ArithDialect, func::FuncDialect, LLVM::LLVMDialect,
+ vector::VectorDialect>();
}
StringRef getArgument() const final { return "test-arith-emulate-wide-int"; }
StringRef getDescription() const final {
typeConverter.addTargetMaterialization(addBitcast);
ConversionTarget target(*ctx);
- target.addDynamicallyLegalDialect<arith::ArithmeticDialect,
- vector::VectorDialect>(
- [&typeConverter](Operation *op) { return typeConverter.isLegal(op); });
+ target
+ .addDynamicallyLegalDialect<arith::ArithDialect, vector::VectorDialect>(
+ [&typeConverter](Operation *op) {
+ return typeConverter.isLegal(op);
+ });
RewritePatternSet patterns(ctx);
arith::populateWideIntEmulationPatterns(typeConverter, patterns);
} // namespace
namespace mlir::test {
-void registerTestArithmeticEmulateWideIntPass() {
+void registerTestArithEmulateWideIntPass() {
PassRegistration<TestEmulateWideIntPass>();
}
} // namespace mlir::test
add_subdirectory(Affine)
-add_subdirectory(Arithmetic)
+add_subdirectory(Arith)
add_subdirectory(DLTI)
add_subdirectory(Func)
add_subdirectory(GPU)
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/Transforms/Passes.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestGpuRewritePass)
void getDependentDialects(DialectRegistry ®istry) const override {
- registry.insert<arith::ArithmeticDialect, func::FuncDialect,
+ registry.insert<arith::ArithDialect, func::FuncDialect,
memref::MemRefDialect>();
}
StringRef getArgument() const final { return "test-gpu-rewrite"; }
LINK_LIBS PUBLIC
MLIRAffineDialect
- MLIRArithmeticDialect
- MLIRArithmeticTransforms
+ MLIRArithDialect
+ MLIRArithTransforms
MLIRBufferizationDialect
MLIRBufferizationTransforms
MLIRGPUTransforms
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Math/Transforms/Passes.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Pass/Pass.h"
void runOnOperation() override;
StringRef getArgument() const final { return "test-expand-math"; }
void getDependentDialects(DialectRegistry ®istry) const override {
- registry.insert<arith::ArithmeticDialect, scf::SCFDialect>();
+ registry.insert<arith::ArithDialect, scf::SCFDialect>();
}
StringRef getDescription() const final { return "Test expanding math"; }
};
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/Math/Transforms/Passes.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h"
void runOnOperation() override;
void getDependentDialects(DialectRegistry ®istry) const override {
- registry.insert<arith::ArithmeticDialect, math::MathDialect,
+ registry.insert<arith::ArithDialect, math::MathDialect,
vector::VectorDialect>();
if (enableAvx2)
registry.insert<x86vector::X86VectorDialect>();
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Utils/Utils.h"
#include "mlir/IR/Builders.h"
}
void getDependentDialects(DialectRegistry ®istry) const override {
- registry.insert<arith::ArithmeticDialect>();
+ registry.insert<arith::ArithDialect>();
}
void runOnOperation() override {
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
}
void getDependentDialects(DialectRegistry ®istry) const override {
- registry.insert<arith::ArithmeticDialect, memref::MemRefDialect>();
+ registry.insert<arith::ArithDialect, memref::MemRefDialect>();
}
void runOnOperation() override {
EXCLUDE_FROM_LIBMLIR
LINK_LIBS PUBLIC
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRLinalgDialect
MLIRPass
MLIRSCFDialect
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
TestTensorTransforms(const TestTensorTransforms &pass) : PassWrapper(pass) {}
void getDependentDialects(DialectRegistry ®istry) const override {
- registry.insert<arith::ArithmeticDialect, scf::SCFDialect,
- linalg::LinalgDialect>();
+ registry
+ .insert<arith::ArithDialect, scf::SCFDialect, linalg::LinalgDialect>();
}
StringRef getArgument() const final {
#include "TestAttributes.h"
#include "TestInterfaces.h"
#include "TestTypes.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/DLTI/DLTI.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "TestDialect.h"
#include "TestTypes.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Func/Transforms/FuncConversions.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/FunctionInterfaces.h"
#include "mlir/IR/Matchers.h"
LINK_LIBS PUBLIC
MLIRAffineDialect
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRLinalgDialect
MLIRLinalgTransforms
MLIRMemRefDialect
set(test_libs
MLIRTestFuncToLLVM
MLIRAffineTransformsTestPasses
- MLIRArithmeticTestPasses
+ MLIRArithTestPasses
MLIRDLTITestPasses
MLIRFuncTestPasses
MLIRGPUTestPasses
void registerPatternsTestPass();
void registerSimpleParametricTilingPass();
void registerTestAffineLoopParametricTilingPass();
-void registerTestArithmeticEmulateWideIntPass();
+void registerTestArithEmulateWideIntPass();
void registerTestAliasAnalysisPass();
void registerTestBuiltinAttributeInterfaces();
void registerTestCallGraphPass();
mlir::test::registerSimpleParametricTilingPass();
mlir::test::registerTestAffineLoopParametricTilingPass();
mlir::test::registerTestAliasAnalysisPass();
- mlir::test::registerTestArithmeticEmulateWideIntPass();
+ mlir::test::registerTestArithEmulateWideIntPass();
mlir::test::registerTestBuiltinAttributeInterfaces();
mlir::test::registerTestCallGraphPass();
mlir::test::registerTestConstantFold();
target_link_libraries(mlir-spirv-cpu-runner PRIVATE
${conversion_libs}
MLIRAnalysis
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRExecutionEngine
MLIRFuncDialect
MLIRGPUOps
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h"
#include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/GPU/Transforms/Passes.h"
jitRunnerConfig.llvmModuleBuilder = convertMLIRModule;
mlir::DialectRegistry registry;
- registry.insert<mlir::arith::ArithmeticDialect, mlir::LLVM::LLVMDialect,
+ registry.insert<mlir::arith::ArithDialect, mlir::LLVM::LLVMDialect,
mlir::gpu::GPUDialect, mlir::spirv::SPIRVDialect,
mlir::func::FuncDialect, mlir::memref::MemRefDialect>();
mlir::registerLLVMDialectTranslation(registry);
set(LIBS
${conversion_libs}
MLIRAnalysis
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRExecutionEngine
MLIRFuncDialect
MLIRGPUOps
#include "mlir/Conversion/LLVMCommon/LoweringOptions.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/GPU/Transforms/Passes.h"
jitRunnerConfig.mlirTransformer = runMLIRPasses;
mlir::DialectRegistry registry;
- registry.insert<mlir::arith::ArithmeticDialect, mlir::LLVM::LLVMDialect,
+ registry.insert<mlir::arith::ArithDialect, mlir::LLVM::LLVMDialect,
mlir::gpu::GPUDialect, mlir::spirv::SPIRVDialect,
mlir::func::FuncDialect, mlir::memref::MemRefDialect>();
mlir::registerLLVMDialectTranslation(registry);
)
target_link_libraries(MLIRPDLToPDLInterpTests
PRIVATE
- MLIRArithmeticDialect
+ MLIRArithDialect
MLIRPDLToPDLInterp
)
//===----------------------------------------------------------------------===//
#include "../lib/Conversion/PDLToPDLInterp/RootOrdering.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/MLIRContext.h"
#include "gtest/gtest.h"
class RootOrderingTest : public ::testing::Test {
protected:
RootOrderingTest() {
- context.loadDialect<ArithmeticDialect>();
+ context.loadDialect<ArithDialect>();
createValues();
}
target_link_libraries(MLIRExecutionEngineTests
PRIVATE
- MLIRArithmeticToLLVM
+ MLIRArithToLLVM
MLIRExecutionEngine
MLIRLinalgToLLVM
MLIRMemRefToLLVM
//
//===----------------------------------------------------------------------===//
-#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
+#include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
static LogicalResult lowerToLLVMDialect(ModuleOp module) {
PassManager pm(module.getContext());
pm.addPass(mlir::createMemRefToLLVMConversionPass());
- pm.addNestedPass<func::FuncOp>(mlir::createArithmeticToLLVMConversionPass());
+ pm.addNestedPass<func::FuncOp>(mlir::createArithToLLVMConversionPass());
pm.addPass(mlir::createConvertFuncToLLVMPass());
pm.addPass(mlir::createReconcileUnrealizedCastsPass());
return pm.run(module);
//===----------------------------------------------------------------------===//
#include "mlir/Interfaces/InferTypeOpInterface.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h"
}
)MLIR";
- registry.insert<func::FuncDialect, arith::ArithmeticDialect>();
+ registry.insert<func::FuncDialect, arith::ArithDialect>();
ctx.appendDialectRegistry(registry);
module = parseSourceString<ModuleOp>(ir, &ctx);
mapFn = cast<func::FuncOp>(module->front());
],
includes = ["include"],
deps = [
- ":ArithmeticOpsTdFiles",
+ ":ArithOpsTdFiles",
":FuncTdFiles",
":LoopLikeInterfaceTdFiles",
":OpBaseTdFiles",
]),
hdrs = glob(["include/mlir/Target/Cpp/*.h"]),
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":ControlFlowDialect",
":EmitCDialect",
":FuncDialect",
],
includes = ["include"],
deps = [
- ":ArithmeticOpsTdFiles",
+ ":ArithOpsTdFiles",
":FuncTdFiles",
":LLVMOpsTdFiles",
":OpBaseTdFiles",
hdrs = ["include/mlir/Dialect/X86Vector/Transforms.h"],
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":FuncDialect",
":IR",
":LLVMCommonConversion",
deps = [
":AffineAnalysis",
":AffineDialect",
- ":ArithmeticDialect",
- ":ArithmeticUtils",
+ ":ArithDialect",
+ ":ArithUtils",
":BufferizationDialect",
":BufferizationTransforms",
":DialectUtils",
hdrs = ["include/mlir/Dialect/SparseTensor/IR/SparseTensor.h"],
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":IR",
":InferTypeOpInterface",
":SparseTensorAttrDefsIncGen",
hdrs = glob(["include/mlir/Dialect/SparseTensor/Utils/*.h"]),
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":ComplexDialect",
":IR",
":LinalgDialect",
includes = ["include"],
deps = [
":AffineDialect",
- ":ArithmeticDialect",
+ ":ArithDialect",
":BufferizationDialect",
":BufferizationTransforms",
":ComplexDialect",
hdrs = ["include/mlir/Dialect/SparseTensor/Pipelines/Passes.h"],
includes = ["include"],
deps = [
- ":ArithmeticTransforms",
+ ":ArithTransforms",
":BufferizationTransforms",
":ConversionPasses",
":FuncDialect",
includes = ["include"],
deps = [
":AffineDialect",
- ":ArithmeticDialect",
+ ":ArithDialect",
":FuncDialect",
":GPUDialect",
":IR",
]),
includes = ["include"],
deps = [
- ":ArithmeticUtils",
+ ":ArithUtils",
":DialectUtilsIncGen",
":IR",
":Support",
deps = [
":AffineMemoryOpInterfacesIncGen",
":AffineOpsIncGen",
- ":ArithmeticDialect",
+ ":ArithDialect",
":ControlFlowInterfaces",
":DialectUtils",
":IR",
includes = ["include"],
deps = [
":Analysis",
- ":ArithmeticDialect",
+ ":ArithDialect",
":AsyncDialect",
":AsyncPassIncGen",
":ControlFlowDialect",
deps = [
":AffineDialect",
":Analysis",
- ":ArithmeticDialect",
+ ":ArithDialect",
":FuncDialect",
":IR",
":Support",
":AffineAnalysis",
":AffineDialect",
":Analysis",
- ":ArithmeticUtils",
+ ":ArithUtils",
":FuncDialect",
":IR",
":MemRefDialect",
":AffinePassIncGen",
":AffineUtils",
":Analysis",
- ":ArithmeticDialect",
- ":ArithmeticUtils",
+ ":ArithDialect",
+ ":ArithUtils",
":FuncDialect",
":IR",
":MemRefDialect",
deps = [
":AMDGPUToROCDL",
":AffineToStandard",
- ":ArithmeticToLLVM",
- ":ArithmeticToSPIRV",
+ ":ArithToLLVM",
+ ":ArithToSPIRV",
":ArmNeon2dToIntr",
":AsyncToLLVM",
":BufferizationToMemRef",
hdrs = glob(["include/mlir/Conversion/AsyncToLLVM/*.h"]),
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":AsyncDialect",
":ConversionPassIncGen",
":FuncDialect",
deps = [
":AffineDialect",
":AffineUtils",
- ":ArithmeticDialect",
+ ":ArithDialect",
":ConversionPassIncGen",
":FuncDialect",
":IR",
),
includes = ["include"],
deps = [
- ":ArithmeticDialect",
- ":ArithmeticUtils",
+ ":ArithDialect",
+ ":ArithUtils",
":BufferizationDialect",
":ControlFlowDialect",
":ControlFlowInterfaces",
":AffineAnalysis",
":AffineDialect",
":Analysis",
- ":ArithmeticDialect",
+ ":ArithDialect",
":DialectUtils",
":FuncDialect",
":IR",
hdrs = ["include/mlir/Dialect/Shape/IR/Shape.h"],
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":ControlFlowInterfaces",
":Dialect",
":FuncDialect",
hdrs = ["include/mlir/Conversion/ShapeToStandard/ShapeToStandard.h"],
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":ControlFlowDialect",
":ConversionPassIncGen",
":FuncDialect",
],
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":BufferizationDialect",
":BufferizationTransforms",
":FuncDialect",
]),
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":CommonFolders",
":ControlFlowInterfaces",
":ControlFlowOpsIncGen",
]) + ["include/mlir/Transforms/InliningUtils.h"],
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":CallOpInterfaces",
":CastOpInterfaces",
":CommonFolders",
]),
includes = ["include"],
deps = [
- ":ArithmeticDialect",
- ":ArithmeticUtils",
+ ":ArithDialect",
+ ":ArithUtils",
":ControlFlowInterfaces",
":DialectUtils",
":IR",
includes = ["include"],
deps = [
":AffineDialect",
- ":ArithmeticDialect",
- ":ArithmeticUtils",
+ ":ArithDialect",
+ ":ArithUtils",
":BufferizationDialect",
":BufferizationTransforms",
":DialectUtils",
deps = [
":AffineAnalysis",
":AffineDialect",
- ":ArithmeticDialect",
+ ":ArithDialect",
":FuncDialect",
":IR",
":MemRefDialect",
hdrs = glob(["include/mlir/Dialect/GPU/IR/*.h"]),
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":DLTIDialect",
":GPUBaseIncGen",
":GPUOpsIncGen",
defines = if_cuda_available(["MLIR_GPU_TO_CUBIN_PASS_ENABLE"]),
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":AsmParser",
":AsyncDialect",
":ControlFlowDialect",
]),
includes = ["include"],
deps = [
- ":ArithmeticDialect",
- ":ArithmeticToLLVM",
+ ":ArithDialect",
+ ":ArithToLLVM",
":ControlFlowDialect",
":ControlFlowToLLVM",
":ConversionPassIncGen",
includes = ["include"],
deps = [
":AMDGPUToROCDL",
- ":ArithmeticToLLVM",
+ ":ArithToLLVM",
":ControlFlowToLLVM",
":ConversionPassIncGen",
":FuncDialect",
hdrs = ["include/mlir/Conversion/GPUCommon/GPUCommonPass.h"],
includes = ["include"],
deps = [
- ":ArithmeticToLLVM",
+ ":ArithToLLVM",
":AsyncDialect",
":AsyncToLLVM",
":ControlFlowToLLVM",
"lib/Conversions/GPUToSPIRV",
],
deps = [
- ":ArithmeticToSPIRV",
+ ":ArithToSPIRV",
":ConversionPassIncGen",
":FuncToSPIRV",
":GPUDialect",
]),
includes = ["include"],
deps = [
- ":ArithmeticToLLVM",
+ ":ArithToLLVM",
":ConversionPassIncGen",
":FuncDialect",
":FuncToLLVM",
"lib/Conversion/TensorToLinalg",
],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":ConversionPassIncGen",
":FuncDialect",
":IR",
"lib/Conversion/TensorToSPIRV",
],
deps = [
- ":ArithmeticToSPIRV",
+ ":ArithToSPIRV",
":ControlFlowToSPIRV",
":ConversionPassIncGen",
":FuncDialect",
hdrs = ["include/mlir/Dialect/Tensor/IR/Tensor.h"],
includes = ["include"],
deps = [
- ":ArithmeticDialect",
- ":ArithmeticUtils",
+ ":ArithDialect",
+ ":ArithUtils",
":CastOpInterfaces",
":ComplexDialect",
":ControlFlowInterfaces",
includes = ["include"],
deps = [
":AffineDialect",
- ":ArithmeticUtils",
+ ":ArithUtils",
":IR",
":LinalgDialect",
":SCFDialect",
includes = ["include"],
deps = [
":AffineDialect",
- ":ArithmeticDialect",
+ ":ArithDialect",
":TensorDialect",
"//llvm:Support",
],
deps = [
":AffineDialect",
":AffineUtils",
- ":ArithmeticDialect",
- ":ArithmeticUtils",
+ ":ArithDialect",
+ ":ArithUtils",
":BufferizationDialect",
":BufferizationTransforms",
":DialectUtils",
deps = [
":AffineDialect",
":AffineToStandard",
- ":ArithmeticDialect",
+ ":ArithDialect",
":ComplexDialect",
":ConversionPassIncGen",
":FuncDialect",
includes = ["include"],
deps = [
":AffineDialect",
- ":ArithmeticToSPIRV",
+ ":ArithToSPIRV",
":ConversionPassIncGen",
":FuncDialect",
":FuncToSPIRV",
deps = [
":AffineAnalysis",
":Analysis",
- ":ArithmeticDialect",
+ ":ArithDialect",
":ConversionPassIncGen",
":FuncDialect",
":IR",
hdrs = ["include/mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"],
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":ControlFlowDialect",
":ConversionPassIncGen",
":FuncDialect",
includes = ["include"],
deps = [
":Analysis",
- ":ArithmeticToLLVM",
+ ":ArithToLLVM",
":ControlFlowToLLVM",
":ConversionPassIncGen",
":DataLayoutInterfaces",
includes = ["include"],
deps = [
":Analysis",
- ":ArithmeticToLLVM",
+ ":ArithToLLVM",
":ControlFlowDialect",
":ConversionPassIncGen",
":DataLayoutInterfaces",
includes = ["include"],
deps = [
":Analysis",
- ":ArithmeticDialect",
+ ":ArithDialect",
":ConversionPassIncGen",
":DataLayoutInterfaces",
":FuncDialect",
)
cc_library(
- name = "ArithmeticToLLVM",
- srcs = glob(["lib/Conversion/ArithmeticToLLVM/*.cpp"]),
- hdrs = glob(["include/mlir/Conversion/ArithmeticToLLVM/*.h"]),
+ name = "ArithToLLVM",
+ srcs = glob(["lib/Conversion/ArithToLLVM/*.cpp"]),
+ hdrs = glob(["include/mlir/Conversion/ArithToLLVM/*.h"]),
includes = ["include"],
deps = [
":Analysis",
- ":ArithmeticDialect",
+ ":ArithDialect",
":ConversionPassIncGen",
":IR",
":LLVMCommonConversion",
)
cc_library(
- name = "ArithmeticToSPIRV",
- srcs = glob(["lib/Conversion/ArithmeticToSPIRV/*.cpp"]),
- hdrs = glob(["include/mlir/Conversion/ArithmeticToSPIRV/*.h"]),
+ name = "ArithToSPIRV",
+ srcs = glob(["lib/Conversion/ArithToSPIRV/*.cpp"]),
+ hdrs = glob(["include/mlir/Conversion/ArithToSPIRV/*.h"]),
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":ConversionPassIncGen",
":FuncToSPIRV",
":IR",
hdrs = glob(["include/mlir/Conversion/MathToFuncs/*.h"]),
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":ControlFlowDialect",
":ConversionPassIncGen",
":DialectUtils",
),
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":CallOpInterfaces",
":ControlFlowInterfaces",
":DataLayoutInterfaces",
":AffinePassIncGen",
":AffineToStandard",
":AffineTransforms",
- ":ArithmeticDialect",
- ":ArithmeticToLLVM",
- ":ArithmeticToSPIRV",
- ":ArithmeticTransforms",
+ ":ArithDialect",
+ ":ArithToLLVM",
+ ":ArithToSPIRV",
+ ":ArithTransforms",
":ArmNeonDialect",
":ArmSVEDialect",
":ArmSVETransforms",
"//llvm:Support",
"//mlir/test:TestAffine",
"//mlir/test:TestAnalysis",
- "//mlir/test:TestArithmetic",
+ "//mlir/test:TestArith",
"//mlir/test:TestDLTI",
"//mlir/test:TestDialect",
"//mlir/test:TestFunc",
name = "mlir-vulkan-runner",
srcs = ["tools/mlir-vulkan-runner/mlir-vulkan-runner.cpp"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":ExecutionEngineUtils",
":FuncDialect",
":FuncToLLVM",
name = "mlir-spirv-cpu-runner",
srcs = ["tools/mlir-spirv-cpu-runner/mlir-spirv-cpu-runner.cpp"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":ExecutionEngineUtils",
":FuncDialect",
":FuncToLLVM",
]),
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":ConversionPassIncGen",
":FuncDialect",
":IR",
]),
includes = ["include"],
deps = [
- ":ArithmeticToLLVM",
+ ":ArithToLLVM",
":ControlFlowToLLVM",
":ConversionPassIncGen",
":FuncDialect",
],
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":FuncDialect",
":IR",
":InferTypeOpInterface",
includes = ["include"],
deps = [
":AffineDialect",
- ":ArithmeticDialect",
- ":ArithmeticUtils",
+ ":ArithDialect",
+ ":ArithUtils",
":AsmParser",
":BufferizationDialect",
":ComplexDialect",
includes = ["include"],
deps = [
":AffineDialect",
- ":ArithmeticDialect",
+ ":ArithDialect",
":AsmParser",
":ControlFlowDialect",
":GPUDialect",
":AffineDialect",
":AffineUtils",
":Analysis",
- ":ArithmeticDialect",
- ":ArithmeticUtils",
+ ":ArithDialect",
+ ":ArithUtils",
":DialectUtils",
":FuncDialect",
":IR",
":AffineDialect",
":AffineUtils",
":Analysis",
- ":ArithmeticDialect",
- ":ArithmeticTransforms",
- ":ArithmeticUtils",
+ ":ArithDialect",
+ ":ArithTransforms",
+ ":ArithUtils",
":BufferizationDialect",
":BufferizationTransforms",
":ComplexDialect",
deps = [
":AMXDialect",
":AMXTransforms",
- ":ArithmeticDialect",
- ":ArithmeticUtils",
+ ":ArithDialect",
+ ":ArithUtils",
":ArmNeonDialect",
":ArmSVEDialect",
":ArmSVETransforms",
deps = [
":AffineDialect",
":Analysis",
- ":ArithmeticDialect",
+ ":ArithDialect",
":ConversionPassIncGen",
":DialectUtils",
":FuncDialect",
deps = [
":AffineDialect",
":AffineUtils",
- ":ArithmeticDialect",
+ ":ArithDialect",
":ConversionPassIncGen",
":FuncDialect",
":FuncToLLVM",
includes = ["include"],
deps = [
":Analysis",
- ":ArithmeticDialect",
+ ":ArithDialect",
":Dialect",
":DialectUtils",
":FuncDialect",
"lib/Conversion/TosaToArith",
],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":ConversionPassIncGen",
":FuncDialect",
":IR",
"lib/Conversion/TosaToLinalg",
],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":ConversionPassIncGen",
":DialectUtils",
":FuncDialect",
"lib/Conversion/TosaToTensor",
],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":ConversionPassIncGen",
":FuncDialect",
":IR",
hdrs = ["include/mlir/Dialect/Complex/IR/Complex.h"],
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":ComplexAttributesIncGen",
":ComplexBaseIncGen",
":ComplexOpsIncGen",
]),
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":ComplexDialect",
":ConversionPassIncGen",
":FuncDialect",
]),
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":ComplexDialect",
":ConversionPassIncGen",
":FuncDialect",
])
td_library(
- name = "ArithmeticOpsTdFiles",
+ name = "ArithOpsTdFiles",
srcs = [
- "include/mlir/Dialect/Arithmetic/IR/ArithmeticBase.td",
- "include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.td",
+ "include/mlir/Dialect/Arith/IR/ArithBase.td",
+ "include/mlir/Dialect/Arith/IR/ArithOps.td",
],
includes = ["include"],
deps = [
)
gentbl_cc_library(
- name = "ArithmeticBaseIncGen",
+ name = "ArithBaseIncGen",
strip_include_prefix = "include",
tbl_outs = [
(
"-gen-dialect-decls",
"-dialect=arith",
],
- "include/mlir/Dialect/Arithmetic/IR/ArithmeticOpsDialect.h.inc",
+ "include/mlir/Dialect/Arith/IR/ArithOpsDialect.h.inc",
),
(
[
"-gen-dialect-defs",
"-dialect=arith",
],
- "include/mlir/Dialect/Arithmetic/IR/ArithmeticOpsDialect.cpp.inc",
+ "include/mlir/Dialect/Arith/IR/ArithOpsDialect.cpp.inc",
),
(
["-gen-enum-decls"],
- "include/mlir/Dialect/Arithmetic/IR/ArithmeticOpsEnums.h.inc",
+ "include/mlir/Dialect/Arith/IR/ArithOpsEnums.h.inc",
),
(
["-gen-enum-defs"],
- "include/mlir/Dialect/Arithmetic/IR/ArithmeticOpsEnums.cpp.inc",
+ "include/mlir/Dialect/Arith/IR/ArithOpsEnums.cpp.inc",
),
],
tblgen = ":mlir-tblgen",
- td_file = "include/mlir/Dialect/Arithmetic/IR/ArithmeticBase.td",
- deps = [":ArithmeticOpsTdFiles"],
+ td_file = "include/mlir/Dialect/Arith/IR/ArithBase.td",
+ deps = [":ArithOpsTdFiles"],
)
gentbl_cc_library(
- name = "ArithmeticOpsIncGen",
+ name = "ArithOpsIncGen",
strip_include_prefix = "include",
tbl_outs = [
(
["-gen-op-decls"],
- "include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.h.inc",
+ "include/mlir/Dialect/Arith/IR/ArithOps.h.inc",
),
(
["-gen-op-defs"],
- "include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc",
+ "include/mlir/Dialect/Arith/IR/ArithOps.cpp.inc",
),
],
tblgen = ":mlir-tblgen",
- td_file = "include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.td",
+ td_file = "include/mlir/Dialect/Arith/IR/ArithOps.td",
deps = [
- ":ArithmeticOpsTdFiles",
+ ":ArithOpsTdFiles",
],
)
gentbl_cc_library(
- name = "ArithmeticCanonicalizationIncGen",
- strip_include_prefix = "include/mlir/Dialect/Arithmetic/IR",
+ name = "ArithCanonicalizationIncGen",
+ strip_include_prefix = "include/mlir/Dialect/Arith/IR",
tbl_outs = [
(
["-gen-rewriters"],
- "include/mlir/Dialect/Arithmetic/IR/ArithmeticCanonicalization.inc",
+ "include/mlir/Dialect/Arith/IR/ArithCanonicalization.inc",
),
],
tblgen = ":mlir-tblgen",
- td_file = "lib/Dialect/Arithmetic/IR/ArithmeticCanonicalization.td",
+ td_file = "lib/Dialect/Arith/IR/ArithCanonicalization.td",
deps = [
- ":ArithmeticOpsTdFiles",
+ ":ArithOpsTdFiles",
":CastInterfacesTdFiles",
":FuncTdFiles",
],
)
cc_library(
- name = "ArithmeticDialect",
+ name = "ArithDialect",
srcs = glob(
[
- "lib/Dialect/Arithmetic/IR/*.cpp",
- "lib/Dialect/Arithmetic/IR/*.h",
+ "lib/Dialect/Arith/IR/*.cpp",
+ "lib/Dialect/Arith/IR/*.h",
],
),
hdrs = [
- "include/mlir/Dialect/Arithmetic/IR/Arithmetic.h",
+ "include/mlir/Dialect/Arith/IR/Arith.h",
"include/mlir/Transforms/InliningUtils.h",
],
includes = ["include"],
deps = [
- ":ArithmeticBaseIncGen",
- ":ArithmeticCanonicalizationIncGen",
- ":ArithmeticOpsIncGen",
+ ":ArithBaseIncGen",
+ ":ArithCanonicalizationIncGen",
+ ":ArithOpsIncGen",
":CommonFolders",
":IR",
":InferIntRangeInterface",
)
gentbl_cc_library(
- name = "ArithmeticPassIncGen",
+ name = "ArithPassIncGen",
strip_include_prefix = "include",
tbl_outs = [
(
[
"-gen-pass-decls",
- "-name=Arithmetic",
+ "-name=Arith",
],
- "include/mlir/Dialect/Arithmetic/Transforms/Passes.h.inc",
+ "include/mlir/Dialect/Arith/Transforms/Passes.h.inc",
),
],
tblgen = ":mlir-tblgen",
- td_file = "include/mlir/Dialect/Arithmetic/Transforms/Passes.td",
+ td_file = "include/mlir/Dialect/Arith/Transforms/Passes.td",
deps = [":PassBaseTdFiles"],
)
cc_library(
- name = "ArithmeticTransforms",
+ name = "ArithTransforms",
srcs = glob([
- "lib/Dialect/Arithmetic/Transforms/*.cpp",
- "lib/Dialect/Arithmetic/Transforms/*.h",
+ "lib/Dialect/Arith/Transforms/*.cpp",
+ "lib/Dialect/Arith/Transforms/*.h",
]),
hdrs = glob([
- "include/mlir/Dialect/Arithmetic/Transforms/*.h",
+ "include/mlir/Dialect/Arith/Transforms/*.h",
]),
includes = ["include"],
deps = [
":Analysis",
- ":ArithmeticDialect",
- ":ArithmeticPassIncGen",
- ":ArithmeticUtils",
+ ":ArithDialect",
+ ":ArithPassIncGen",
+ ":ArithUtils",
":BufferizationDialect",
":BufferizationTransforms",
":FuncDialect",
)
cc_library(
- name = "ArithmeticUtils",
+ name = "ArithUtils",
srcs = glob([
- "lib/Dialect/Arithmetic/Utils/*.cpp",
+ "lib/Dialect/Arith/Utils/*.cpp",
]),
- hdrs = ["include/mlir/Dialect/Arithmetic/Utils/Utils.h"],
+ hdrs = ["include/mlir/Dialect/Arith/Utils/Utils.h"],
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":IR",
"//llvm:Support",
],
],
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":CommonFolders",
":IR",
":InferTypeOpInterface",
hdrs = glob(["include/mlir/Dialect/Math/Transforms/*.h"]),
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":DialectUtils",
":FuncDialect",
":IR",
]),
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":ConversionPassIncGen",
":DialectUtils",
":FuncDialect",
],
includes = ["include"],
deps = [
- ":ArithmeticOpsTdFiles",
+ ":ArithOpsTdFiles",
":CastInterfacesTdFiles",
":ControlFlowInterfacesTdFiles",
":CopyOpInterfaceTdFiles",
],
includes = ["include"],
deps = [
- ":ArithmeticDialect",
- ":ArithmeticUtils",
+ ":ArithDialect",
+ ":ArithUtils",
":ControlFlowInterfaces",
":CopyOpInterface",
":DialectUtils",
deps = [
":AffineDialect",
":AffineUtils",
- ":ArithmeticDialect",
- ":ArithmeticTransforms",
- ":ArithmeticUtils",
+ ":ArithDialect",
+ ":ArithTransforms",
+ ":ArithUtils",
":DialectUtils",
":FuncDialect",
":IR",
includes = ["include"],
deps = [
":AffineDialect",
- ":ArithmeticDialect",
+ ":ArithDialect",
":IR",
":MemRefDialect",
":MemRefTransformOpsIncGen",
deps = [
":AffineDialect",
":AllocationOpInterface",
- ":ArithmeticDialect",
+ ":ArithDialect",
":BufferizableOpInterfaceIncGen",
":BufferizationBaseIncGen",
":BufferizationOpsIncGen",
deps = [
":AllocationOpInterface",
":Analysis",
- ":ArithmeticDialect",
+ ":ArithDialect",
":BufferizationDialect",
":BufferizationPassIncGen",
":ControlFlowInterfaces",
],
includes = ["include"],
deps = [
- ":ArithmeticDialect",
+ ":ArithDialect",
":BufferizationDialect",
":ConversionPassIncGen",
":FuncDialect",
"//mlir:AffineTransforms",
"//mlir:AllPassesAndDialects",
"//mlir:Analysis",
- "//mlir:ArithmeticDialect",
+ "//mlir:ArithDialect",
"//mlir:CastOpInterfaces",
"//mlir:FuncDialect",
"//mlir:IR",
"//mlir:AffineTransforms",
"//mlir:AllPassesAndDialects",
"//mlir:Analysis",
- "//mlir:ArithmeticDialect",
- "//mlir:ArithmeticToLLVM",
+ "//mlir:ArithDialect",
+ "//mlir:ArithToLLVM",
"//mlir:CastOpInterfaces",
"//mlir:ControlFlowToLLVM",
"//mlir:ExecutionEngine",
"//mlir:AffineTransforms",
"//mlir:AllPassesAndDialects",
"//mlir:Analysis",
- "//mlir:ArithmeticDialect",
- "//mlir:ArithmeticToLLVM",
+ "//mlir:ArithDialect",
+ "//mlir:ArithToLLVM",
"//mlir:CastOpInterfaces",
"//mlir:ControlFlowToLLVM",
"//mlir:ExecutionEngine",
)
##---------------------------------------------------------------------------##
-# Arithmetic dialect.
+# Arith dialect.
##---------------------------------------------------------------------------##
td_library(
- name = "ArithmeticOpsPyTdFiles",
+ name = "ArithOpsPyTdFiles",
srcs = [
"//mlir:include/mlir/Bindings/Python/Attributes.td",
],
includes = ["../include"],
deps = [
- "//mlir:ArithmeticOpsTdFiles",
+ "//mlir:ArithOpsTdFiles",
"//mlir:OpBaseTdFiles",
],
)
gentbl_filegroup(
- name = "ArithmeticOpsPyGen",
+ name = "ArithOpsPyGen",
tbl_outs = [
(
[
),
],
tblgen = "//mlir:mlir-tblgen",
- td_file = "mlir/dialects/ArithmeticOps.td",
+ td_file = "mlir/dialects/ArithOps.td",
deps = [
- ":ArithmeticOpsPyTdFiles",
+ ":ArithOpsPyTdFiles",
],
)
filegroup(
- name = "ArithmeticOpsPyFiles",
+ name = "ArithOpsPyFiles",
srcs = [
"mlir/dialects/_arith_ops_ext.py",
"mlir/dialects/arith.py",
- ":ArithmeticOpsPyGen",
+ ":ArithOpsPyGen",
],
)
":TestOpsIncGen",
":TestTypeDefsIncGen",
"//llvm:Support",
- "//mlir:ArithmeticDialect",
+ "//mlir:ArithDialect",
"//mlir:ControlFlowInterfaces",
"//mlir:CopyOpInterface",
"//mlir:DLTIDialect",
":TestDialect",
"//llvm:Support",
"//mlir:Analysis",
- "//mlir:ArithmeticDialect",
+ "//mlir:ArithDialect",
"//mlir:FuncDialect",
"//mlir:IR",
"//mlir:LinalgDialect",
deps = [
"//llvm:Support",
"//mlir:AffineDialect",
- "//mlir:ArithmeticDialect",
+ "//mlir:ArithDialect",
"//mlir:FuncDialect",
"//mlir:IR",
"//mlir:LinalgDialect",
"//mlir:AffineAnalysis",
"//mlir:AffineDialect",
"//mlir:Analysis",
- "//mlir:ArithmeticDialect",
+ "//mlir:ArithDialect",
"//mlir:FuncDialect",
"//mlir:IR",
"//mlir:MathDialect",
"//llvm:NVPTXCodeGen",
"//llvm:Support",
"//mlir:AffineDialect",
- "//mlir:ArithmeticDialect",
+ "//mlir:ArithDialect",
"//mlir:FuncDialect",
"//mlir:GPUDialect",
"//mlir:GPUTransforms",
deps = [
"//llvm:Support",
"//mlir:AffineDialect",
- "//mlir:ArithmeticDialect",
- "//mlir:ArithmeticTransforms",
+ "//mlir:ArithDialect",
+ "//mlir:ArithTransforms",
"//mlir:BufferizationDialect",
"//mlir:BufferizationTransforms",
"//mlir:FuncDialect",
defines = ["MLIR_CUDA_CONVERSIONS_ENABLED"],
includes = ["lib/Dialect/Test"],
deps = [
- "//mlir:ArithmeticDialect",
+ "//mlir:ArithDialect",
"//mlir:MathDialect",
"//mlir:MathTransforms",
"//mlir:Pass",
includes = ["lib/Dialect/Test"],
deps = [
"//llvm:Support",
- "//mlir:ArithmeticDialect",
+ "//mlir:ArithDialect",
"//mlir:FuncDialect",
"//mlir:IR",
"//mlir:MathDialect",
)
cc_library(
- name = "TestArithmetic",
- srcs = glob(["lib/Dialect/Arithmetic/*.cpp"]),
+ name = "TestArith",
+ srcs = glob(["lib/Dialect/Arith/*.cpp"]),
defines = ["MLIR_CUDA_CONVERSIONS_ENABLED"],
includes = ["lib/Dialect/Test"],
deps = [
- "//mlir:ArithmeticDialect",
- "//mlir:ArithmeticTransforms",
+ "//mlir:ArithDialect",
+ "//mlir:ArithTransforms",
"//mlir:FuncDialect",
"//mlir:LLVMDialect",
"//mlir:MathDialect",
defines = ["MLIR_CUDA_CONVERSIONS_ENABLED"],
includes = ["lib/Dialect/Test"],
deps = [
- "//mlir:ArithmeticDialect",
+ "//mlir:ArithDialect",
"//mlir:LinalgDialect",
"//mlir:Pass",
"//mlir:SCFDialect",
]),
deps = [
"//llvm:gtest_main",
- "//mlir:ArithmeticDialect",
+ "//mlir:ArithDialect",
"//mlir:PDLToPDLInterp",
],
)
projects / platform / upstream / llvm.git / commitdiff