[mlir] Add EmitC dialect

[marbre]

Summary

This upstreams the EmitC dialect and the corresponding Cpp target, both
initially presented with [1], from [2] to MLIR core. For the related
discussion, see [3].

[1] https://reviews.llvm.org/D76571
[2] https://github.com/iml130/mlir-emitc
[3] https://llvm.discourse.group/t/emitc-generating-c-c-from-mlir/3388

Co-authored-by: Jacques Pienaar <[e-mail]>
Co-authored-by: Simon Camphausen <[e-mail]>
Co-authored-by: Oliver Scherf <[e-mail]>

[rriddle]

Thanks, starting to work through it.

Can you split this commit into multiple smaller commits? I think the translation and dialect parts can be separated.

mlir/include/mlir/Dialect/EmitC/IR/EmitC.h

17

What is used from here?

20

This header isn't necessary.

mlir/include/mlir/Dialect/EmitC/IR/EmitC.td

34

Generally the Attributes/Dialect/Ops/Types are in separate .td files.

37

A very common idiom is to pass this as a template arg to the base class.

55–71

Can you move these to the .cpp file?

99–115

Same here and below.

139

Can you move this to the EmitC_Op class?

163

Why not constant? That generally matches the naming in the rest of the ecosystem.

166–169

Why do you reference std.constant here? Is that necessary? (std.constant may eventually, hopefully, go away)

181

nit: include or Include?

mlir/include/mlir/Target/Cpp/Cpp.h

1 ↗

(On Diff #350913)

Cpp seems a bit too general given that this is seemingly only focused on EmitC.

25 ↗

(On Diff #350913)

Can you document this?

122 ↗

(On Diff #350913)

Can you use an active phrasing? shouldMapToSigned?

185 ↗

(On Diff #350913)

Please fix the naming on these.

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

53

nit: Drop all of the mlir::, you also don't need the emitc for quite a few of these either.

57

nit: Drop the trivial braces here.

74

Drop trivial braces here and throughought.

[rriddle]

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

80–98

Can you do something to reduce the nesting here? In general, we prefer "early exit" style coding.

137

nit: Drop this line, it doesn't add anything.

mlir/lib/Target/Cpp/TranslateRegistration.cpp

19 ↗

(On Diff #350913)

Prefer using explicit scoping:
https://llvm.org/docs/CodingStandards.html#use-namespace-qualifiers-to-implement-previously-declared-functions

28 ↗

(On Diff #350913)

nit: Drop the llvm:: here and below.

mlir/lib/Target/Cpp/TranslateToCpp.cpp

29 ↗

(On Diff #350913)

Only the very first part of this function needs to know what ConstOpTy is, can you refactor to avoid a template?

32 ↗

(On Diff #350913)

nit: auto should only be used when it helps readability:

https://llvm.org/docs/CodingStandards.html#use-auto-type-deduction-to-make-code-more-readable

[marbre]

Address review comments

Removes the target. This will be included in a separate commit.

[jpienaar]

mlir/include/mlir/Dialect/EmitC/IR/EmitC.td

36

This is for applying a prefix unary operator? What is the benefit of this one op vs an AddressOf and DereferenceOp ? (And yeah with operator overloading these may not do that ... StarPrefix or the like is probably more generally correct)

68

Given opaque types, should there be a restriction added in use of this op? If one were to create a constant of a C++ class with internal state, then it would have side effects I think.

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

2

Only need to specify file type in the .h files

[marbre]

Thanks for the review @rriddle. I hope this addresses most suggestions.

I will sent a separate patch that contains the target (your suggestions already applied), but like for additional comments with view on the folloiwing:
I agree that Cpp/Cpp.h isn't an appropriate name, which we simply adopted from @jpienaar's original patch. Do you have a suggestion? Should the name correspond to the dialect which is origin of the translation? In that case one should probably also rename the Cpp directory.
Regarding the use of namespace qualifiers in the target registration, in order to drop the namespace mlir {, we would either need to include mlir/InitAllTranslations.h or we forward declare in the cpp file itself:

namespace mlir {
void registerToCppTranslation()
void registerToCTranslation()
}

Is that what you propose? Right now the registration closely resembles target registrations like registerToSPIRVTranslation().

mlir/include/mlir/Dialect/EmitC/IR/EmitC.h

17

The IncludeOp as HasParent<"ModuleOp"> set.

20

Dropped it.

mlir/include/mlir/Dialect/EmitC/IR/EmitC.td

34

Split those into EmitC, EmitCBase, EmitCAttrDefs and EmitCTypes.

37

Thanks for the hint, done.

163

Why not constant? That generally matches the naming in the rest of the ecosystem.

I wasn't aware that std.constant is possibly going to vanish. Rephrased accordingly.

166–169

Why do you reference std.constant here? Is that necessary? (std.constant may eventually, hopefully, go away)

I renamed to emitc.constant as I have no preference. I think I implemented this op after I looked into the TOSA where the op is indeed called const.

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

53

Thanks, (hopefully) all done.

80–98

I have refactored to at least drop one level of nesting.

[marbre]

mlir/include/mlir/Dialect/EmitC/IR/EmitC.td

36

We limited this to the use of the unary operators * and &. I have no strong preference and we had a GetAddressOfOp, but to me the feedback in an after the ODM indicated that an ApplyOp would be the better fit.

68

I am open to suggestions :) We can drop the NoSideEffect of course.

[rriddle]

Thanks, took another pass. Probably just one more after this one.

mlir/include/mlir/Dialect/EmitC/IR/EmitC.td

17

nit: I'd probably go with EmitCAttributes to match the EmitCTypes filename.

18

This include isn't necessary

30

41

59

Should this use a DenseElementsAttr instead? (Dense storage is generally more efficient)

61

72

Remaining reference to std.constant here?

73–74

The operation is marked with AnyAttr and AnyType though, is it supposed to be constrained to just emitc types? Or is this just remarking that the emitc types are supported in addition to everything else?

mlir/include/mlir/Dialect/EmitC/IR/EmitCAttrDefs.td

45 ↗

(On Diff #351867)

Can you move this to the .cpp? So that is next to the parser code.

mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td

45

Can you move this to the .cpp? So that is next to the parser code.

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

11

What is used from StandardOps?

16

I think some of these includes are unneccesary.

61

76

Can you spell out auto here?

76–77

78

Same here.

93

Can you spell out auto here?

94–95

Attribute is a pointer-like class, prefer passing by value.

97

If you aren't using the result, use isa instead.

118

Can you spell out auto here?

150

Can you spell out auto here?

191

nit: Spell out auto here.

[marbre]

mlir/include/mlir/Dialect/EmitC/IR/EmitC.td

17

Renamed to EmitCAttributes with the next revision.

18

Thanks, dropped it.

59

You can specific the order of operands by passing integer values of index types. In addition, you can specify attributes that get lowered to constants, e.g. floats. With different types occurring, I think we cannot use a DenseElementsAttr. Anyway, I think the description was misleading. Rephrased a little, hoping to pronounce the "and" different.

68

I dropped NoSideEffect with the next revision.

72

Thanks for catching this!

73–74

I intended to express the latter. Rephrased to make this clearer.

mlir/include/mlir/Dialect/EmitC/IR/EmitCAttrDefs.td

45 ↗

(On Diff #351867)

Sure, addressed with the next revision.

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

2

Thanks, I have removed the string in this and also in all *.cpp files relevant for follow up patches.

11

Thanks for taking a careful look! Seems to be a leftover, removed it.

16

Thanks for catching this. Cleaned it up.

76

Spelled out here and in all other places occurring in EmitC.cpp.

97

Thanks for the suggestions. All done.

[marbre]

Address review comments

• Renames EmitCAttrDefs.td to EmitCAttributes.td
• Strip unused includes
• Moves printer from tblgen to cpp
• Revise ConstantOp Drops NoSideEffect trait and rephrases the op description
• Improves code style E.g. replaces auto and improves the CallOp verifier

[rriddle]

Thanks a lot for the work! This looks fine to land and build on.

mlir/include/mlir/Dialect/EmitC/IR/EmitC.td

73–74

I don't know if it is important to explicitly call out (given that they are all in the same dialect, you could probably convey the same by showing an example using those types. No strong preference either way, but as mentioned in another comment; Can you add some examples to the descriptions?

88–89

Can you add an example IR snippet to the descriptions for these operations?

93

mlir/include/mlir/Dialect/EmitC/IR/EmitCAttributes.td

23

mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td

24–25

.td files should also be wrapped at 80 characters.

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

73

Drop the const here, attributes are (essentially) immutable by design.

80–82

89

Drop the const here, attributes are (essentially) immutable by design.

90

This loop doesn't guard against other types of attributes (such as external dialect attributes). Is this just guarding against some known unsupported types? Would it be better to use an allow list as opposed to an explicit deny list?

mlir/test/Dialect/EmitC/ops.mlir

2

Do you need the -allow-unregistered-dialect on this?

mlir/test/Dialect/EmitC/types.mlir

2

Do you need the -allow-unregistered-dialect on these?

[marbre]

In D103969#2824035, @rriddle wrote:

Thanks a lot for the work! This looks fine to land and build on.

Thanks a lot for the review! I addressed your latest comments within the last revision which I will update prior to landing the commit.

[marbre]

mlir/include/mlir/Dialect/EmitC/IR/EmitC.td

73–74

Dropped the last sentence and added examples for all EmitC ops.

88–89

Sure :) Done for all ops.

mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td

24–25

Fixed several lines where line breaks were necessary. Thanks for pointing out.

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

90

Good catch! It does not. Refactored accordingly and now check for supported types.
With C++20 it is even legal to emit floating-point type template parameters.

mlir/test/Dialect/EmitC/ops.mlir

2

We did because of !custom<"int32_t"> and "bar", but I refactored and dropped -allow-unregistered-dialect`.

mlir/test/Dialect/EmitC/types.mlir

2

Dropped it.

[marbre]

Address review comments before landing

mlir/include/mlir/Dialect/CMakeLists.txt

 add_subdirectory(Affine)
 add_subdirectory(Async)
 add_subdirectory(ArmNeon)
 add_subdirectory(ArmSVE)
 add_subdirectory(AMX)
 add_subdirectory(Complex)
 add_subdirectory(DLTI)
+add_subdirectory(EmitC)
 add_subdirectory(GPU)
 add_subdirectory(Math)
 add_subdirectory(Linalg)
 add_subdirectory(LLVMIR)
 add_subdirectory(MemRef)
 add_subdirectory(OpenACC)
 add_subdirectory(OpenMP)
 add_subdirectory(PDL)

mlir/include/mlir/Dialect/EmitC/CMakeLists.txt

+add_subdirectory(IR)

mlir/include/mlir/Dialect/EmitC/IR/CMakeLists.txt

+add_mlir_dialect(EmitC emitc)
+add_mlir_doc(EmitC EmitC Dialects/ -gen-dialect-doc)
+
+set(LLVM_TARGET_DEFINITIONS EmitCAttributes.td)
+mlir_tablegen(EmitCAttributes.h.inc -gen-attrdef-decls)
+mlir_tablegen(EmitCAttributes.cpp.inc -gen-attrdef-defs)
+add_public_tablegen_target(MLIREmitCAttributesIncGen)

mlir/include/mlir/Dialect/EmitC/IR/EmitC.h

+//===- EmitC.h - EmitC 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares EmitC in MLIR.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_EMITC_IR_EMITC_H
+#define MLIR_DIALECT_EMITC_IR_EMITC_H
+
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/Dialect.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
+
+#include "mlir/Dialect/EmitC/IR/EmitCDialect.h.inc"
+
+#define GET_ATTRDEF_CLASSES
+#include "mlir/Dialect/EmitC/IR/EmitCAttributes.h.inc"
+
+#define GET_TYPEDEF_CLASSES
+#include "mlir/Dialect/EmitC/IR/EmitCTypes.h.inc"
+
+#define GET_OP_CLASSES
+#include "mlir/Dialect/EmitC/IR/EmitC.h.inc"
+
+#endif // MLIR_DIALECT_EMITC_IR_EMITC_H

mlir/include/mlir/Dialect/EmitC/IR/EmitC.td

+//===- EmitC.td - EmitC operations--------------------------*- tablegen -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines the MLIR EmitC operations.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_EMITC_IR_EMITC
+#define MLIR_DIALECT_EMITC_IR_EMITC
+
+include "mlir/Dialect/EmitC/IR/EmitCAttributes.td"
+include "mlir/Dialect/EmitC/IR/EmitCTypes.td"
+
+include "mlir/Interfaces/SideEffectInterfaces.td"
+
+//===----------------------------------------------------------------------===//
+// EmitC op definitions
+//===----------------------------------------------------------------------===//
+
+// Base class for EmitC dialect ops.
+class EmitC_Op<string mnemonic, list<OpTrait> traits = []>
+    : Op<EmitC_Dialect, mnemonic, traits> {
+  let verifier = "return ::verify(*this);";
+}
+
+def EmitC_ApplyOp : EmitC_Op<"apply", []> {
+  let summary = "Apply operation";
+  let description = [{
+    With the `apply` operation the operators & (address of) and * (contents of)
+    can be applied to a single operand.
+
+    Example:
+
+    ```mlir
+    // Custom form of applying the & operator.
+    %0 = emitc.apply "&"(%arg0) : (i32) -> !emitc.opaque<"int32_t*">
+
+    // Generic form of the same operation.
+    %0 = "emitc.apply"(%arg0) {applicableOperator = "&"}
+        : (i32) -> !emitc.opaque<"int32_t*">
+
+    ```
+  }];
+  let arguments = (ins
+    Arg<StrAttr, "the operator to apply">:$applicableOperator,
+    AnyType:$operand
+  );
+  let results = (outs AnyType:$result);
+  let assemblyFormat = [{
+    $applicableOperator `(` $operand `)` attr-dict `:` functional-type($operand, results)
+  }];
+}
+
+def EmitC_CallOp : EmitC_Op<"call", []> {
+  let summary = "Call operation";
+  let description = [{
+    The `call` operation represents a C++ function call. The call allows
+    specifying order of operands and attributes in the call as follows:
+
+    - integer value of index type refers to an operand;
+    - attribute which will get lowered to constant value in call;
+
+    Example:
+
+    ```mlir
+    // Custom form defining a call to `foo()`.
+    %0 = emitc.call "foo" () : () -> i32
+
+    // Generic form of the same operation.
+    %0 = "emitc.call"() {callee = "foo"} : () -> i32
+    ```
+  }];
+  let arguments = (ins
+    Arg<StrAttr, "the C++ function to call">:$callee,
+    Arg<OptionalAttr<ArrayAttr>, "the order of operands and further attributes">:$args,
+    Arg<OptionalAttr<ArrayAttr>, "template arguments">:$template_args,
+    Variadic<AnyType>:$operands
+  );
+  let results = (outs Variadic<AnyType>);
+  let assemblyFormat = [{
+    $callee `(` $operands `)` attr-dict `:` functional-type($operands, results)
+  }];
+}
+
+def EmitC_ConstantOp : EmitC_Op<"constant", [ConstantLike]> {
+  let summary = "Constant operation";
+  let description = [{
+    The `constant` operation produces an SSA value equal to some constant
+    specified by an attribute. This can be used to form simple integer and
+    floating point constants, as well as more exotic things like tensor
+    constants. The `constant` operation also supports the EmitC opaque
+    attribute and the EmitC opaque type.
+
+    Example:
+
+    ```mlir
+    // Integer constant
+    %0 = "emitc.constant"(){value = 42 : i32} : () -> i32
+
+    // Constant emitted as `int32_t* = NULL;`
+    %1 = "emitc.constant"()
+        {value = #emitc.opaque<"NULL"> : !emitc.opaque<"int32_t*">}
+        : () -> !emitc.opaque<"int32_t*">
+    ```
+  }];
+
+  let arguments = (ins AnyAttr:$value);
+  let results = (outs AnyType);
+
+  let hasFolder = 1;
+}
+
+def EmitC_IncludeOp
+    : EmitC_Op<"include", [NoSideEffect, HasParent<"ModuleOp">]> {
+  let summary = "Include operation";
+  let description = [{
+    The `include` operation allows to define a source file inclusion via the
+    `#include` directive.
+
+    Example:
+
+    ```mlir
+    // Custom form defining the inclusion of `<myheader>`.
+    emitc.include "myheader.h" is_standard_include
+
+    // Generic form of the same operation.
+    "emitc.include" (){include = "myheader.h", is_standard_include} : () -> ()
+
+    // Generic form defining the inclusion of `"myheader"`.
+    "emitc.include" (){include = "myheader.h"} : () -> ()
+    ```
+  }];
+  let arguments = (ins
+    Arg<StrAttr, "source file to include">:$include,
+    UnitAttr:$is_standard_include
+  );
+  let assemblyFormat = [{
+    $include attr-dict (`is_standard_include` $is_standard_include^)?
+  }];
+  let verifier = ?;
+}
+
+#endif // MLIR_DIALECT_EMITC_IR_EMITC

mlir/include/mlir/Dialect/EmitC/IR/EmitCAttributes.td

+//===- EmitCAttributes.td - EmitC attributes ---------------*- tablegen -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines the MLIR EmitC attributes.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_EMITC_IR_EMITCATTRIBUTES
+#define MLIR_DIALECT_EMITC_IR_EMITCATTRIBUTES
+
+include "mlir/Dialect/EmitC/IR/EmitCBase.td"
+
+//===----------------------------------------------------------------------===//
+// EmitC attribute definitions
+//===----------------------------------------------------------------------===//
+
+class EmitC_Attr<string name, string attrMnemonic>
+    : AttrDef<EmitC_Dialect, name> {
+  let mnemonic = attrMnemonic;
+}
+
+def EmitC_OpaqueAttr : EmitC_Attr<"Opaque", "opaque"> {
+  let summary = "An opaque attribute";
+
+  let description = [{
+    An opaque attribute of which the value gets emitted as is.
+
+    Example:
+
+    ```mlir
+    #emitc.opaque<"">
+    #emitc.opaque<"NULL">
+    #emitc.opaque<"nullptr">
+    ```
+  }];
+
+  let parameters = (ins StringRefParameter<"the opaque value">:$value);
+}
+
+#endif // MLIR_DIALECT_EMITC_IR_EMITCATTRIBUTES

mlir/include/mlir/Dialect/EmitC/IR/EmitCBase.td

+//===- EmitCBase.td - EmitC 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.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines the MLIR EmitC dialect.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_EMITC_IR_EMITCBASE
+#define MLIR_DIALECT_EMITC_IR_EMITCBASE
+
+include "mlir/IR/OpBase.td"
+
+//===----------------------------------------------------------------------===//
+// EmitC dialect definition
+//===----------------------------------------------------------------------===//
+
+def EmitC_Dialect : Dialect {
+  let name = "emitc";
+  let cppNamespace = "::mlir::emitc";
+  let hasConstantMaterializer = 1;
+}
+
+#endif // MLIR_DIALECT_EMITC_IR_EMITCBASE

mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td

+//===- EmitCTypes.td - EmitC types -------------------------*- tablegen -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines the MLIR EmitC types.
+//
+//===----------------------------------------------------------------------===//
+
+
+#ifndef MLIR_DIALECT_EMITC_IR_EMITCTYPES
+#define MLIR_DIALECT_EMITC_IR_EMITCTYPES
+
+include "mlir/Dialect/EmitC/IR/EmitCBase.td"
+
+//===----------------------------------------------------------------------===//
+// EmitC type definitions
+//===----------------------------------------------------------------------===//
+
+class EmitC_Type<string name, string typeMnemonic>
+    : TypeDef<EmitC_Dialect, name> {
+  let mnemonic = typeMnemonic;
+}
+
+def EmitC_OpaqueType : EmitC_Type<"Opaque", "opaque"> {
+  let summary = "An opaque type";
+
+  let description = [{
+    An opaque data type of which the value gets emitted as is.
+
+    Example:
+
+    ```mlir
+    !emitc.opaque<"int">
+    !emitc.opaque<"float *">
+    !emitc.opaque<"std::vector<std::string>">
+    ```
+  }];
+
+  let parameters = (ins StringRefParameter<"the opaque value">:$value);
+}
+
+#endif // MLIR_DIALECT_EMITC_IR_EMITCTYPES

mlir/include/mlir/InitAllDialects.h

 
 #include "mlir/Dialect/AMX/AMXDialect.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/ArmNeon/ArmNeonDialect.h"
 #include "mlir/Dialect/ArmSVE/ArmSVEDialect.h"
 #include "mlir/Dialect/Async/IR/Async.h"
 #include "mlir/Dialect/Complex/IR/Complex.h"
 #include "mlir/Dialect/DLTI/DLTI.h"
+#include "mlir/Dialect/EmitC/IR/EmitC.h"
 #include "mlir/Dialect/GPU/GPUDialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/LLVMIR/NVVMDialect.h"
 #include "mlir/Dialect/LLVMIR/ROCDLDialect.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/OpenACC/OpenACC.h"
inline void registerAllDialects(DialectRegistry &registry) {
   // clang-format off
   registry.insert<acc::OpenACCDialect,
                   AffineDialect,
                   amx::AMXDialect,
                   arm_neon::ArmNeonDialect,
                   async::AsyncDialect,
                   complex::ComplexDialect,
                   DLTIDialect,
+                  emitc::EmitCDialect,
                   gpu::GPUDialect,
                   LLVM::LLVMDialect,
                   linalg::LinalgDialect,
                   math::MathDialect,
                   memref::MemRefDialect,
                   scf::SCFDialect,
                   omp::OpenMPDialect,
                   pdl::PDLDialect,

mlir/lib/Dialect/CMakeLists.txt

 add_subdirectory(Affine)
 add_subdirectory(ArmNeon)
 add_subdirectory(ArmSVE)
 add_subdirectory(Async)
 add_subdirectory(AMX)
 add_subdirectory(Complex)
 add_subdirectory(DLTI)
+add_subdirectory(EmitC)
 add_subdirectory(GPU)
 add_subdirectory(Linalg)
 add_subdirectory(LLVMIR)
 add_subdirectory(Math)
 add_subdirectory(MemRef)
 add_subdirectory(OpenACC)
 add_subdirectory(OpenMP)
 add_subdirectory(PDL)

mlir/lib/Dialect/EmitC/CMakeLists.txt

+add_subdirectory(IR)

mlir/lib/Dialect/EmitC/IR/CMakeLists.txt

+add_mlir_dialect_library(MLIREmitC
+  EmitC.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/EmitC
+
+  DEPENDS
+  MLIREmitCIncGen
+  MLIREmitCAttributesIncGen
+
+  LINK_LIBS PUBLIC
+  MLIRIR
+  MLIRSideEffectInterfaces
+  )

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

+//===- EmitC.cpp - EmitC Dialect ------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/EmitC/IR/EmitC.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/DialectImplementation.h"
+#include "llvm/ADT/TypeSwitch.h"
+
+using namespace mlir;
+using namespace mlir::emitc;
+
+//===----------------------------------------------------------------------===//
+// EmitCDialect
+//===----------------------------------------------------------------------===//
+
+void EmitCDialect::initialize() {
+  addOperations<
+#define GET_OP_LIST
+#include "mlir/Dialect/EmitC/IR/EmitC.cpp.inc"
+      >();
+  addTypes<
+#define GET_TYPEDEF_LIST
+#include "mlir/Dialect/EmitC/IR/EmitCTypes.cpp.inc"
+      >();
+  addAttributes<
+#define GET_ATTRDEF_LIST
+#include "mlir/Dialect/EmitC/IR/EmitCAttributes.cpp.inc"
+      >();
+}
+
+/// Materialize a single constant operation from a given attribute value with
+/// the desired resultant type.
+Operation *EmitCDialect::materializeConstant(OpBuilder &builder,
+                                             Attribute value, Type type,
+                                             Location loc) {
+  return builder.create<ConstantOp>(loc, type, value);
+}
+
+//===----------------------------------------------------------------------===//
+// ApplyOp
+//===----------------------------------------------------------------------===//
+
+static LogicalResult verify(ApplyOp op) {
+  StringRef applicableOperator = op.applicableOperator();
+
+  // Applicable operator must not be empty.
+  if (applicableOperator.empty())
+    return op.emitOpError("applicable operator must not be empty");
+
+  // Only `*` and `&` are supported.
+  if (applicableOperator != "&" && applicableOperator != "*")
+    return op.emitOpError("applicable operator is illegal");
+
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
+// CallOp
+//===----------------------------------------------------------------------===//
+
+static LogicalResult verify(emitc::CallOp op) {
+  // Callee must not be empty.
+  if (op.callee().empty())
+    return op.emitOpError("callee must not be empty");
+
+  if (Optional<ArrayAttr> argsAttr = op.args()) {
+    for (Attribute arg : argsAttr.getValue()) {
+      if (arg.getType().isa<IndexType>()) {
+        int64_t index = arg.cast<IntegerAttr>().getInt();
+        // Args with elements of type index must be in range
+        // [0..operands.size).
+        if ((index < 0) || (index >= static_cast<int64_t>(op.getNumOperands())))
+          return op.emitOpError("index argument is out of range");
+
+        // Args with elements of type ArrayAttr must have a type.
+      } else if (arg.isa<ArrayAttr>() && arg.getType().isa<NoneType>()) {
+        return op.emitOpError("array argument has no type");
+      }
+    }
+  }
+
+  if (Optional<ArrayAttr> templateArgsAttr = op.template_args()) {
+    for (Attribute tArg : templateArgsAttr.getValue()) {
+      if (!tArg.isa<TypeAttr>() && !tArg.isa<IntegerAttr>() &&
+          !tArg.isa<FloatAttr>() && !tArg.isa<emitc::OpaqueAttr>())
+        return op.emitOpError("template argument has invalid type");
+    }
+  }
+
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
+// ConstantOp
+//===----------------------------------------------------------------------===//
+
+/// The constant op requires that the attribute's type matches the return type.
+static LogicalResult verify(emitc::ConstantOp &op) {
+  Attribute value = op.value();
+  Type type = op.getType();
+  if (!value.getType().isa<NoneType>() && type != value.getType())
+    return op.emitOpError() << "requires attribute's type (" << value.getType()
+                            << ") to match op's return type (" << type << ")";
+  return success();
+}
+
+OpFoldResult emitc::ConstantOp::fold(ArrayRef<Attribute> operands) {
+  assert(operands.empty() && "constant has no operands");
+  return value();
+}
+
+//===----------------------------------------------------------------------===//
+// TableGen'd op method definitions
+//===----------------------------------------------------------------------===//
+
+#define GET_OP_CLASSES
+#include "mlir/Dialect/EmitC/IR/EmitC.cpp.inc"
+
+//===----------------------------------------------------------------------===//
+// EmitC Attributes
+//===----------------------------------------------------------------------===//
+
+#define GET_ATTRDEF_CLASSES
+#include "mlir/Dialect/EmitC/IR/EmitCAttributes.cpp.inc"
+
+Attribute emitc::OpaqueAttr::parse(MLIRContext *context,
+                                   DialectAsmParser &parser, Type type) {
+  if (parser.parseLess())
+    return Attribute();
+  StringRef value;
+  llvm::SMLoc loc = parser.getCurrentLocation();
+  if (parser.parseOptionalString(&value)) {
+    parser.emitError(loc) << "expected string";
+    return Attribute();
+  }
+  if (parser.parseGreater())
+    return Attribute();
+  return get(context, value);
+}
+
+Attribute EmitCDialect::parseAttribute(DialectAsmParser &parser,
+                                       Type type) const {
+  llvm::SMLoc typeLoc = parser.getCurrentLocation();
+  StringRef mnemonic;
+  if (parser.parseKeyword(&mnemonic))
+    return Attribute();
+  Attribute genAttr;
+  OptionalParseResult parseResult =
+      generatedAttributeParser(getContext(), parser, mnemonic, type, genAttr);
+  if (parseResult.hasValue())
+    return genAttr;
+  parser.emitError(typeLoc, "unknown attribute in EmitC dialect");
+  return Attribute();
+}
+
+void EmitCDialect::printAttribute(Attribute attr, DialectAsmPrinter &os) const {
+  if (failed(generatedAttributePrinter(attr, os)))
+    llvm_unreachable("unexpected 'EmitC' attribute kind");
+}
+
+void emitc::OpaqueAttr::print(DialectAsmPrinter &printer) const {
+  printer << "opaque<\"" << getValue() << "\">";
+}
+
+//===----------------------------------------------------------------------===//
+// EmitC Types
+//===----------------------------------------------------------------------===//
+
+#define GET_TYPEDEF_CLASSES
+#include "mlir/Dialect/EmitC/IR/EmitCTypes.cpp.inc"
+
+Type emitc::OpaqueType::parse(MLIRContext *context, DialectAsmParser &parser) {
+  if (parser.parseLess())
+    return Type();
+  StringRef value;
+  llvm::SMLoc loc = parser.getCurrentLocation();
+  if (parser.parseOptionalString(&value) || value.empty()) {
+    parser.emitError(loc) << "expected non empty string";
+    return Type();
+  }
+  if (parser.parseGreater())
+    return Type();
+  return get(context, value);
+}
+
+Type EmitCDialect::parseType(DialectAsmParser &parser) const {
+  llvm::SMLoc typeLoc = parser.getCurrentLocation();
+  StringRef mnemonic;
+  if (parser.parseKeyword(&mnemonic))
+    return Type();
+  Type genType;
+  OptionalParseResult parseResult =
+      generatedTypeParser(getContext(), parser, mnemonic, genType);
+  if (parseResult.hasValue())
+    return genType;
+  parser.emitError(typeLoc, "unknown type in EmitC dialect");
+  return Type();
+}
+
+void EmitCDialect::printType(Type type, DialectAsmPrinter &os) const {
+  if (failed(generatedTypePrinter(type, os)))
+    llvm_unreachable("unexpected 'EmitC' type kind");
+}
+
+void emitc::OpaqueType::print(DialectAsmPrinter &printer) const {
+  printer << "opaque<\"" << getValue() << "\">";
+}

mlir/test/Dialect/EmitC/invalid_ops.mlir

+// RUN: mlir-opt %s -split-input-file -verify-diagnostics
+
+func @const_attribute_return_type_1() {
+    // expected-error @+1 {{'emitc.constant' op requires attribute's type ('i64') to match op's return type ('i32')}}
+    %c0 = "emitc.constant"(){value = 42: i64} : () -> i32
+    return
+}
+
+// -----
+
+func @const_attribute_return_type_2() {
+    // expected-error @+1 {{'emitc.constant' op requires attribute's type ('!emitc.opaque<"int32_t*">') to match op's return type ('!emitc.opaque<"int32_t">')}}
+    %c0 = "emitc.constant"(){value = "nullptr" : !emitc.opaque<"int32_t*">} : () -> !emitc.opaque<"int32_t">
+    return
+}
+
+// -----
+
+func @index_args_out_of_range_1() {
+    // expected-error @+1 {{'emitc.call' op index argument is out of range}}
+    emitc.call "test" () {args = [0 : index]} : () -> ()
+    return
+}
+
+// -----
+
+func @index_args_out_of_range_2(%arg : i32) {
+    // expected-error @+1 {{'emitc.call' op index argument is out of range}}
+    emitc.call "test" (%arg, %arg) {args = [2 : index]} : (i32, i32) -> ()
+    return
+}
+
+// -----
+
+func @empty_callee() {
+    // expected-error @+1 {{'emitc.call' op callee must not be empty}}
+    emitc.call "" () : () -> ()
+    return
+}
+
+// -----
+
+func @nonetype_arg(%arg : i32) {
+    // expected-error @+1 {{'emitc.call' op array argument has no type}}
+    emitc.call "nonetype_arg"(%arg) {args = [0 : index, [0, 1, 2]]} : (i32) -> i32
+    return
+}
+
+// -----
+
+func @array_template_arg(%arg : i32) {
+    // expected-error @+1 {{'emitc.call' op template argument has invalid type}}
+    emitc.call "nonetype_template_arg"(%arg) {template_args = [[0, 1, 2]]} : (i32) -> i32
+    return
+}
+
+// -----
+
+func @dense_template_argument(%arg : i32) {
+    // expected-error @+1 {{'emitc.call' op template argument has invalid type}}
+    emitc.call "dense_template_argument"(%arg) {template_args = [dense<[1.0, 1.0]> : tensor<2xf32>]} : (i32) -> i32
+    return
+}
+
+// -----
+
+func @empty_operator(%arg : i32) {
+    // expected-error @+1 {{'emitc.apply' op applicable operator must not be empty}}
+    %2 = emitc.apply ""(%arg) : (i32) -> !emitc.opaque<"int32_t*">
+    return
+}
+
+// -----
+
+func @illegal_operator(%arg : i32) {
+    // expected-error @+1 {{'emitc.apply' op applicable operator is illegal}}
+    %2 = emitc.apply "+"(%arg) : (i32) -> !emitc.opaque<"int32_t*">
+    return
+}

mlir/test/Dialect/EmitC/ops.mlir

+// RUN: mlir-opt -verify-diagnostics %s | FileCheck %s
+
+"emitc.include" (){include = "test.h", is_standard_include} : () -> ()
+emitc.include "test.h" is_standard_include
+
+// CHECK-LABEL: func @f(%{{.*}}: i32, %{{.*}}: !emitc.opaque<"int32_t">) {
+func @f(%arg0: i32, %f: !emitc.opaque<"int32_t">) {
+  %1 = "emitc.call"() {callee = "blah"} : () -> i64
+  emitc.call "foo" (%1) {args = [
+    0 : index, dense<[0, 1]> : tensor<2xi32>, 0 : index
+  ]} : (i64) -> ()
+  return
+}
+
+func @c(%arg0: i32) {
+  %1 = "emitc.constant"(){value = 42 : i32} : () -> i32
+  return
+}
+
+func @a(%arg0: i32, %arg1: i32) {
+  %1 = "emitc.apply"(%arg0) {applicableOperator = "&"} : (i32) -> !emitc.opaque<"int32_t*">
+  %2 = emitc.apply "&"(%arg1) : (i32) -> !emitc.opaque<"int32_t*">
+  return
+}

mlir/test/Dialect/EmitC/types.mlir

+// RUN: mlir-opt -verify-diagnostics %s | FileCheck %s
+// check parser
+// RUN: mlir-opt -verify-diagnostics %s | mlir-opt -verify-diagnostics | FileCheck %s
+
+// CHECK-LABEL: func @opaque_types() {
+func @opaque_types() {
+  // CHECK-NEXT: !emitc.opaque<"int">
+  emitc.call "f"() {args = [!emitc<"opaque<\"int\">">]} : () -> ()
+  // CHECK-NEXT: !emitc.opaque<"byte">
+  emitc.call "f"() {args = [!emitc<"opaque<\"byte\">">]} : () -> ()
+  // CHECK-NEXT: !emitc.opaque<"unsigned">
+  emitc.call "f"() {args = [!emitc<"opaque<\"unsigned\">">]} : () -> ()
+  // CHECK-NEXT: !emitc.opaque<"status_t">
+  emitc.call "f"() {args = [!emitc<"opaque<\"status_t\">">]} : () -> ()
+  // CHECK-NEXT: !emitc.opaque<"std::vector<std::string>">
+  emitc.call "f"() {args = [!emitc.opaque<"std::vector<std::string>">]} : () -> ()
+  return
+}

mlir/test/mlir-opt/commandline.mlir

 // RUN: mlir-opt --show-dialects | FileCheck %s
 // CHECK: Available Dialects:
 // CHECK-NEXT: acc
 // CHECK-NEXT: affine
 // CHECK-NEXT: amx
 // CHECK-NEXT: arm_neon
 // CHECK-NEXT: arm_sve
 // CHECK-NEXT: async
 // CHECK-NEXT: complex
 // CHECK-NEXT: dlti
+// CHECK-NEXT: emitc
 // CHECK-NEXT: gpu
 // CHECK-NEXT: linalg
 // CHECK-NEXT: llvm
 // CHECK-NEXT: math
 // CHECK-NEXT: memref
 // CHECK-NEXT: nvvm
 // CHECK-NEXT: omp
 // CHECK-NEXT: pdl