Switch from C-style comments `/* ... */` to C++ style `//` (NFC)

[mehdi_amini]

Summary

This is mostly a scripted update, it may not be perfect.

function replace() {

FROM=$1
TO=$2
git grep "$FROM" $REPO_PATH |cut -f 1 -d : | sort -u | \
  while read file; do
    sed -i "s#$FROM#$TO#" $file ;
  done

}

replace '|\*===----------------------------------------------------------------------===\*|$' '===----------------------------------------------------------------------==='
replace '^/\* =' '=='
replace '^/\*=' '='
replace '^\\\*=' '='
replace '^|\*' ''
replace ' \*|$' ''
replace '=\*\\$' '='
replace '== \*/$' '==='
replace '==\*/$' '=='
replace '^/\*\*\(.*\)\*/$' '/\1'
replace '^/\*\(.*\)\*/$' '\1'
replace '============================================================================' '===----------------------------------------------------------------------===//'

[mehdi_amini]

Minor tweak

[mehdi_amini]

Update description

[lattner]

Wow, very impressive regex-fu mehdi! It looks like one more pattern is needed, but amazing work!

mlir/lib/CAPI/IR/IR.cpp

163–165

This looks like one more pattern to add to your regex

mlir/tools/mlir-tblgen/PassCAPIGen.cpp

41 ↗

(On Diff #302724)

This line probably shouldn't be included unless tblgen is updated.

[mehdi_amini]

Address comment

[mehdi_amini]

mlir/lib/CAPI/IR/IR.cpp

163–165

Well spotted! (There was a typo in one of the pattern)

[ftynse]

Thanks!

[silvas]

mlir/include/mlir-c/AffineExpr.h

20

Random consistency question:

Why

//============================================================================//

instead of the more typical

//===----------------------------------------------------------------------===//

?

LGTM either way.

[mehdi_amini]

Address Sean's comment

[mehdi_amini]

mlir/include/mlir-c/AffineExpr.h

20

No reason, updated! Thanks.

mlir/docs/OpDefinitions.md

def MyOp : Op<"my_op", []> {
   ];
 }
 ```
 
 The generated code will use default value in the declaration, but not in the
 definition, as required by C++.
 
 ```c++
-/* Header file. */
+/// Header file.
 class MyOp : /*...*/ {
   /*...*/
   static void build(::mlir::OpBuilder &builder, ::mlir::OperationState &state,
                     float val = 0.5f);
 };
 
-/* Source file. */
+/// Source file.
 MyOp::build(::mlir::OpBuilder &builder, ::mlir::OperationState &state,
             float val) {
   state.addAttribute("attr", builder.getF32FloatAttr(val));
 }
 ```
 
 **Deprecated:** `OpBuilder` class allows one to specify the custom builder
 signature as a raw string, without separating parameters into different `dag`

mlir/include/mlir-c/AffineExpr.h

-/*===-- mlir-c/AffineExpr.h - C API for MLIR Affine Expressions ---*- 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                    *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
+//===-- mlir-c/AffineExpr.h - C API for MLIR Affine Expressions ---*- 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_C_AFFINEEXPR_H
 #define MLIR_C_AFFINEEXPR_H
 
 #include "mlir-c/AffineMap.h"
 #include "mlir-c/IR.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
 /** Opaque type declarations.
  *
  * Types are exposed to C bindings as structs containing opaque pointers. They
  * are not supposed to be inspected from C. This allows the underlying
  * representation to change without affecting the API users. The use of structs
  * instead of typedefs enables some type safety as structs are not implicitly
  * convertible to each other.
  *
  * Instances of these types may or may not own the underlying object. The
  * ownership semantics is defined by how an instance of the type was obtained.
  */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
 
 #define DEFINE_C_API_STRUCT(name, storage)                                     \
   struct name {                                                                \
     storage *ptr;                                                              \
   };                                                                           \
   typedef struct name name
 
 DEFINE_C_API_STRUCT(MlirAffineExpr, const void);
 
 #undef DEFINE_C_API_STRUCT
 
-/** Gets the context that owns the affine expression. */
+/// Gets the context that owns the affine expression.
 MlirContext mlirAffineExprGetContext(MlirAffineExpr affineExpr);
 
 /** Prints an affine expression by sending chunks of the string representation
  * and forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
 void mlirAffineExprPrint(MlirAffineExpr affineExpr, MlirStringCallback callback,
                          void *userData);
 
-/** Prints the affine expression to the standard error stream. */
+/// Prints the affine expression to the standard error stream.
 void mlirAffineExprDump(MlirAffineExpr affineExpr);
 
 /** Checks whether the given affine expression is made out of only symbols and
  * constants. */
 int mlirAffineExprIsSymbolicOrConstant(MlirAffineExpr affineExpr);
 
 /** Checks whether the given affine expression is a pure affine expression, i.e.
  * mul, floordiv, ceildic, and mod is only allowed w.r.t constants. */
 int mlirAffineExprIsPureAffine(MlirAffineExpr affineExpr);
 
 /** Returns the greatest known integral divisor of this affine expression. The
  * result is always positive. */
 int64_t mlirAffineExprGetLargestKnownDivisor(MlirAffineExpr affineExpr);
 
-/** Checks whether the given affine expression is a multiple of 'factor'. */
+/// Checks whether the given affine expression is a multiple of 'factor'.
 int mlirAffineExprIsMultipleOf(MlirAffineExpr affineExpr, int64_t factor);
 
 /** Checks whether the given affine expression involves AffineDimExpr
  * 'position'. */
 int mlirAffineExprIsFunctionOfDim(MlirAffineExpr affineExpr, intptr_t position);
 
-/*============================================================================*/
-/* Affine Dimension Expression.                                               */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine Dimension Expression.
+//===----------------------------------------------------------------------===//
 
-/** Creates an affine dimension expression with 'position' in the context. */
+/// Creates an affine dimension expression with 'position' in the context.
 MlirAffineExpr mlirAffineDimExprGet(MlirContext ctx, intptr_t position);
 
-/** Returns the position of the given affine dimension expression. */
+/// Returns the position of the given affine dimension expression.
 intptr_t mlirAffineDimExprGetPosition(MlirAffineExpr affineExpr);
 
-/*============================================================================*/
-/* Affine Symbol Expression.                                                  */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine Symbol Expression.
+//===----------------------------------------------------------------------===//
 
-/** Creates an affine symbol expression with 'position' in the context. */
+/// Creates an affine symbol expression with 'position' in the context.
 MlirAffineExpr mlirAffineSymbolExprGet(MlirContext ctx, intptr_t position);
 
-/** Returns the position of the given affine symbol expression. */
+/// Returns the position of the given affine symbol expression.
 intptr_t mlirAffineSymbolExprGetPosition(MlirAffineExpr affineExpr);
 
-/*============================================================================*/
-/* Affine Constant Expression.                                                */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine Constant Expression.
+//===----------------------------------------------------------------------===//
 
-/** Creates an affine constant expression with 'constant' in the context. */
+/// Creates an affine constant expression with 'constant' in the context.
 MlirAffineExpr mlirAffineConstantExprGet(MlirContext ctx, int64_t constant);
 
-/** Returns the value of the given affine constant expression. */
+/// Returns the value of the given affine constant expression.
 int64_t mlirAffineConstantExprGetValue(MlirAffineExpr affineExpr);
 
-/*============================================================================*/
-/* Affine Add Expression.                                                     */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine Add Expression.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given affine expression is an add expression. */
+/// Checks whether the given affine expression is an add expression.
 int mlirAffineExprIsAAdd(MlirAffineExpr affineExpr);
 
-/** Creates an affine add expression with 'lhs' and 'rhs'. */
+/// Creates an affine add expression with 'lhs' and 'rhs'.
 MlirAffineExpr mlirAffineAddExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs);
 
-/*============================================================================*/
-/* Affine Mul Expression.                                                     */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine Mul Expression.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given affine expression is an mul expression. */
+/// Checks whether the given affine expression is an mul expression.
 int mlirAffineExprIsAMul(MlirAffineExpr affineExpr);
 
-/** Creates an affine mul expression with 'lhs' and 'rhs'. */
+/// Creates an affine mul expression with 'lhs' and 'rhs'.
 MlirAffineExpr mlirAffineMulExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs);
 
-/*============================================================================*/
-/* Affine Mod Expression.                                                     */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine Mod Expression.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given affine expression is an mod expression. */
+/// Checks whether the given affine expression is an mod expression.
 int mlirAffineExprIsAMod(MlirAffineExpr affineExpr);
 
-/** Creates an affine mod expression with 'lhs' and 'rhs'. */
+/// Creates an affine mod expression with 'lhs' and 'rhs'.
 MlirAffineExpr mlirAffineModExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs);
 
-/*============================================================================*/
-/* Affine FloorDiv Expression.                                                */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine FloorDiv Expression.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given affine expression is an floordiv expression. */
+/// Checks whether the given affine expression is an floordiv expression.
 int mlirAffineExprIsAFloorDiv(MlirAffineExpr affineExpr);
 
-/** Creates an affine floordiv expression with 'lhs' and 'rhs'. */
+/// Creates an affine floordiv expression with 'lhs' and 'rhs'.
 MlirAffineExpr mlirAffineFloorDivExprGet(MlirAffineExpr lhs,
                                          MlirAffineExpr rhs);
 
-/*============================================================================*/
-/* Affine CeilDiv Expression.                                                 */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine CeilDiv Expression.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given affine expression is an ceildiv expression. */
+/// Checks whether the given affine expression is an ceildiv expression.
 int mlirAffineExprIsACeilDiv(MlirAffineExpr affineExpr);
 
-/** Creates an affine ceildiv expression with 'lhs' and 'rhs'. */
+/// Creates an affine ceildiv expression with 'lhs' and 'rhs'.
 MlirAffineExpr mlirAffineCeilDivExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs);
 
-/*============================================================================*/
-/* Affine Binary Operation Expression.                                        */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine Binary Operation Expression.
+//===----------------------------------------------------------------------===//
 
 /** Returns the left hand side affine expression of the given affine binary
  * operation expression. */
 MlirAffineExpr mlirAffineBinaryOpExprGetLHS(MlirAffineExpr affineExpr);
 
 /** Returns the right hand side affine expression of the given affine binary
  * operation expression. */
 MlirAffineExpr mlirAffineBinaryOpExprGetRHS(MlirAffineExpr affineExpr);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_AFFINEEXPR_H

mlir/include/mlir-c/AffineMap.h

-/*===-- mlir-c/AffineMap.h - C API for MLIR Affine maps -----------*- 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                    *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
+//===-- mlir-c/AffineMap.h - C API for MLIR Affine maps -----------*- 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_C_AFFINEMAP_H
 #define MLIR_C_AFFINEMAP_H
 
 #include "mlir-c/IR.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
 /** Opaque type declarations.
  *
  * Types are exposed to C bindings as structs containing opaque pointers. They
  * are not supposed to be inspected from C. This allows the underlying
  * representation to change without affecting the API users. The use of structs
  * instead of typedefs enables some type safety as structs are not implicitly
  * convertible to each other.
  *
  * Instances of these types may or may not own the underlying object. The
  * ownership semantics is defined by how an instance of the type was obtained.
  */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
 
 #define DEFINE_C_API_STRUCT(name, storage)                                     \
   struct name {                                                                \
     storage *ptr;                                                              \
   };                                                                           \
   typedef struct name name
 
 DEFINE_C_API_STRUCT(MlirAffineMap, const void);
 
 #undef DEFINE_C_API_STRUCT
 
-/** Gets the context that the given affine map was created with*/
+/// Gets the context that the given affine map was created with
 MlirContext mlirAffineMapGetContext(MlirAffineMap affineMap);
 
-/** Checks whether an affine map is null. */
+/// Checks whether an affine map is null.
 inline int mlirAffineMapIsNull(MlirAffineMap affineMap) {
   return !affineMap.ptr;
 }
 
-/** Checks if two affine maps are equal. */
+/// Checks if two affine maps are equal.
 int mlirAffineMapEqual(MlirAffineMap a1, MlirAffineMap a2);
 
 /** Prints an affine map by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
 void mlirAffineMapPrint(MlirAffineMap affineMap, MlirStringCallback callback,
                         void *userData);
 
-/** Prints the affine map to the standard error stream. */
+/// Prints the affine map to the standard error stream.
 void mlirAffineMapDump(MlirAffineMap affineMap);
 
 /** Creates a zero result affine map with no dimensions or symbols in the
  * context. The affine map is owned by the context. */
 MlirAffineMap mlirAffineMapEmptyGet(MlirContext ctx);
 
 /** Creates a zero result affine map of the given dimensions and symbols in the
  * context. The affine map is owned by the context. */

 MlirAffineMap mlirAffineMapPermutationGet(MlirContext ctx, intptr_t size,
                                           unsigned *permutation);
 
 /** Checks whether the given affine map is an identity affine map. The function
  * asserts that the number of dimensions is greater or equal to the number of
  * results. */
 int mlirAffineMapIsIdentity(MlirAffineMap affineMap);
 
-/** Checks whether the given affine map is a minor identity affine map. */
+/// Checks whether the given affine map is a minor identity affine map.
 int mlirAffineMapIsMinorIdentity(MlirAffineMap affineMap);
 
-/** Checks whether the given affine map is an empty affine map. */
+/// Checks whether the given affine map is an empty affine map.
 int mlirAffineMapIsEmpty(MlirAffineMap affineMap);
 
 /** Checks whether the given affine map is a single result constant affine
  * map. */
 int mlirAffineMapIsSingleConstant(MlirAffineMap affineMap);
 
 /** Returns the constant result of the given affine map. The function asserts
  * that the map has a single constant result. */
 int64_t mlirAffineMapGetSingleConstantResult(MlirAffineMap affineMap);
 
-/** Returns the number of dimensions of the given affine map. */
+/// Returns the number of dimensions of the given affine map.
 intptr_t mlirAffineMapGetNumDims(MlirAffineMap affineMap);
 
-/** Returns the number of symbols of the given affine map. */
+/// Returns the number of symbols of the given affine map.
 intptr_t mlirAffineMapGetNumSymbols(MlirAffineMap affineMap);
 
-/** Returns the number of results of the given affine map. */
+/// Returns the number of results of the given affine map.
 intptr_t mlirAffineMapGetNumResults(MlirAffineMap affineMap);
 
 /** Returns the number of inputs (dimensions + symbols) of the given affine
  * map. */
 intptr_t mlirAffineMapGetNumInputs(MlirAffineMap affineMap);
 
 /** Checks whether the given affine map represents a subset of a symbol-less
  * permutation map. */
 int mlirAffineMapIsProjectedPermutation(MlirAffineMap affineMap);
 
 /** Checks whether the given affine map represents a symbol-less permutation
  * map. */
 int mlirAffineMapIsPermutation(MlirAffineMap affineMap);
 
-/** Returns the affine map consisting of the `resultPos` subset. */
+/// Returns the affine map consisting of the `resultPos` subset.
 MlirAffineMap mlirAffineMapGetSubMap(MlirAffineMap affineMap, intptr_t size,
                                      intptr_t *resultPos);
 
 /** Returns the affine map consisting of the most major `numResults` results.
  * Returns the null AffineMap if the `numResults` is equal to zero.
  * Returns the `affineMap` if `numResults` is greater or equals to number of
  * results of the given affine map. */
 MlirAffineMap mlirAffineMapGetMajorSubMap(MlirAffineMap affineMap,

mlir/include/mlir-c/Bindings/Python/Interop.h

-/*===-- mlir-c/Interop.h - Constants for Python/C-API interop -----*- 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 header declares constants and helpers necessary for C-level           *|
-|* interop with the MLIR Python extension module. Since the Python bindings   *|
-|* are a thin wrapper around the MLIR C-API, a further C-API is not provided  *|
-|* specifically for the Python extension. Instead, simple facilities are      *|
-|* provided for translating between Python types and corresponding MLIR C-API *|
-|* types.                                                                     *|
-|*                                                                            *|
-|* This header is standalone, requiring nothing beyond normal linking against *|
-|* the Python implementation.                                                 *|
-\*===----------------------------------------------------------------------===*/
+//===-- mlir-c/Interop.h - Constants for Python/C-API interop -----*- 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 header declares constants and helpers necessary for C-level
+// interop with the MLIR Python extension module. Since the Python bindings
+// are a thin wrapper around the MLIR C-API, a further C-API is not provided
+// specifically for the Python extension. Instead, simple facilities are
+// provided for translating between Python types and corresponding MLIR C-API
+// types.
+//
+// This header is standalone, requiring nothing beyond normal linking against
+// the Python implementation.
+//===----------------------------------------------------------------------===//
 
 #ifndef MLIR_C_BINDINGS_PYTHON_INTEROP_H
 #define MLIR_C_BINDINGS_PYTHON_INTEROP_H
 
 #include <Python.h>
 
 #include "mlir-c/IR.h"
 

mlir/include/mlir-c/Diagnostics.h

-/*===-- mlir-c/Diagnostics.h - MLIR Diagnostic subsystem C API ----*- 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 header declares the C APIs accessing MLIR Diagnostics subsystem.      *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
+//===-- mlir-c/Diagnostics.h - MLIR Diagnostic subsystem C API ----*- 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 header declares the C APIs accessing MLIR Diagnostics subsystem.
+//
+//===----------------------------------------------------------------------===//
 
 #ifndef MLIR_C_DIAGNOSTICS_H
 #define MLIR_C_DIAGNOSTICS_H
 
 #include "mlir-c/IR.h"
 #include "mlir-c/Support.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /** An opaque reference to a diagnostic, always owned by the diagnostics engine
  * (context). Must not be stored outside of the diagnostic handler. */
 struct MlirDiagnostic {
   void *ptr;
 };
 typedef struct MlirDiagnostic MlirDiagnostic;
 
-/** Severity of a diagnostic. */
+/// Severity of a diagnostic.
 enum MlirDiagnosticSeverity {
   MlirDiagnosticError,
   MlirDiagnosticWarning,
   MlirDiagnosticNote,
   MlirDiagnosticRemark
 };
 typedef enum MlirDiagnosticSeverity MlirDiagnosticSeverity;
 
-/** Opaque identifier of a diagnostic handler, useful to detach a handler. */
+/// Opaque identifier of a diagnostic handler, useful to detach a handler.
 typedef uint64_t MlirDiagnosticHandlerID;
 
 /** Diagnostic handler type. Acceps a reference to a diagnostic, which is only
  * guaranteed to be live during the call. If the handler processed the
  * diagnostic completely, it is expected to return success. Otherwise, it is
  * expected to return failure to indicate that other handlers should attempt to
  * process the diagnostic. */
 typedef MlirLogicalResult (*MlirDiagnosticHandler)(MlirDiagnostic);
 
-/** Prints a diagnostic using the provided callback. */
+/// Prints a diagnostic using the provided callback.
 void mlirDiagnosticPrint(MlirDiagnostic diagnostic, MlirStringCallback callback,
                          void *userData);
 
-/** Returns the location at which the diagnostic is reported. */
+/// Returns the location at which the diagnostic is reported.
 MlirLocation mlirDiagnosticGetLocation(MlirDiagnostic diagnostic);
 
-/** Returns the severity of the diagnostic. */
+/// Returns the severity of the diagnostic.
 MlirDiagnosticSeverity mlirDiagnosticGetSeverity(MlirDiagnostic diagnostic);
 
-/** Returns the number of notes attached to the diagnostic. */
+/// Returns the number of notes attached to the diagnostic.
 intptr_t mlirDiagnosticGetNumNotes(MlirDiagnostic diagnostic);
 
 /** Returns `pos`-th note attached to the diagnostic. Expects `pos` to be a
  * valid zero-based index into the list of notes. */
 MlirDiagnostic mlirDiagnosticGetNote(MlirDiagnostic diagnostic, intptr_t pos);
 
 /** Attaches the diagnostic handler to the context. Handlers are invoked in the
  * reverse order of attachment until one of them processes the diagnostic

mlir/include/mlir-c/IR.h

-/*===-- mlir-c/IR.h - C API to Core MLIR IR classes ---------------*- 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 header declares the C interface to MLIR core IR classes.              *|
-|*                                                                            *|
-|* Many exotic languages can interoperate with C code but have a harder time  *|
-|* with C++ due to name mangling. So in addition to C, this interface enables *|
-|* tools written in such languages.                                           *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
+//===-- mlir-c/IR.h - C API to Core MLIR IR classes ---------------*- 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 header declares the C interface to MLIR core IR classes.
+//
+// Many exotic languages can interoperate with C code but have a harder time
+// with C++ due to name mangling. So in addition to C, this interface enables
+// tools written in such languages.
+//
+//===----------------------------------------------------------------------===//
 
 #ifndef MLIR_C_IR_H
 #define MLIR_C_IR_H
 
 #include <stdint.h>
 
 #include "mlir-c/Support.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
 /** Opaque type declarations.
  *
  * Types are exposed to C bindings as structs containing opaque pointers. They
  * are not supposed to be inspected from C. This allows the underlying
  * representation to change without affecting the API users. The use of structs
  * instead of typedefs enables some type safety as structs are not implicitly
  * convertible to each other.
  *
  * Instances of these types may or may not own the underlying object (most often
  * only point to an IR fragment without owning it). The ownership semantics is
  * defined by how an instance of the type was obtained.
  */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
 
 #define DEFINE_C_API_STRUCT(name, storage)                                     \
   struct name {                                                                \
     storage *ptr;                                                              \
   };                                                                           \
   typedef struct name name
 
 DEFINE_C_API_STRUCT(MlirContext, void);

  * to the portion of the string with the following arguments:
  *   - a pointer to the beginning of a string;
  *   - the length of the string (the pointer may point to a larger buffer, not
  *     necessarily null-terminated);
  *   - a pointer to user data forwarded from the printing call.
  */
 typedef void (*MlirStringCallback)(const char *, intptr_t, void *);
 
-/*============================================================================*/
-/* Context API.                                                               */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Context API.
+//===----------------------------------------------------------------------===//
 
-/** Creates an MLIR context and transfers its ownership to the caller. */
+/// Creates an MLIR context and transfers its ownership to the caller.
 MlirContext mlirContextCreate();
 
-/** Checks if two contexts are equal. */
+/// Checks if two contexts are equal.
 int mlirContextEqual(MlirContext ctx1, MlirContext ctx2);
 
-/** Checks whether a context is null. */
+/// Checks whether a context is null.
 static inline int mlirContextIsNull(MlirContext context) {
   return !context.ptr;
 }
 
-/** Takes an MLIR context owned by the caller and destroys it. */
+/// Takes an MLIR context owned by the caller and destroys it.
 void mlirContextDestroy(MlirContext context);
 
-/** Sets whether unregistered dialects are allowed in this context. */
+/// Sets whether unregistered dialects are allowed in this context.
 void mlirContextSetAllowUnregisteredDialects(MlirContext context, int allow);
 
-/** Returns whether the context allows unregistered dialects. */
+/// Returns whether the context allows unregistered dialects.
 int mlirContextGetAllowUnregisteredDialects(MlirContext context);
 
 /** Returns the number of dialects registered with the given context. A
  * registered dialect will be loaded if needed by the parser. */
 intptr_t mlirContextGetNumRegisteredDialects(MlirContext context);
 
 /** Returns the number of dialects loaded by the context.
  */
 intptr_t mlirContextGetNumLoadedDialects(MlirContext context);
 
 /** Gets the dialect instance owned by the given context using the dialect
  * namespace to identify it, loads (i.e., constructs the instance of) the
  * dialect if necessary. If the dialect is not registered with the context,
  * returns null. Use mlirContextLoad<Name>Dialect to load an unregistered
  * dialect. */
 MlirDialect mlirContextGetOrLoadDialect(MlirContext context,
                                         MlirStringRef name);
 
-/*============================================================================*/
-/* Dialect API.                                                               */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Dialect API.
+//===----------------------------------------------------------------------===//
 
-/** Returns the context that owns the dialect. */
+/// Returns the context that owns the dialect.
 MlirContext mlirDialectGetContext(MlirDialect dialect);
 
-/** Checks if the dialect is null. */
+/// Checks if the dialect is null.
 static inline int mlirDialectIsNull(MlirDialect dialect) {
   return !dialect.ptr;
 }
 
 /** Checks if two dialects that belong to the same context are equal. Dialects
  * from different contexts will not compare equal. */
 int mlirDialectEqual(MlirDialect dialect1, MlirDialect dialect2);
 
-/** Returns the namespace of the given dialect. */
+/// Returns the namespace of the given dialect.
 MlirStringRef mlirDialectGetNamespace(MlirDialect dialect);
 
-/*============================================================================*/
-/* Location API.                                                              */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Location API.
+//===----------------------------------------------------------------------===//
 
-/** Creates an File/Line/Column location owned by the given context. */
+/// Creates an File/Line/Column location owned by the given context.
 MlirLocation mlirLocationFileLineColGet(MlirContext context,
                                         const char *filename, unsigned line,
                                         unsigned col);
 
-/** Creates a location with unknown position owned by the given context. */
+/// Creates a location with unknown position owned by the given context.
 MlirLocation mlirLocationUnknownGet(MlirContext context);
 
-/** Gets the context that a location was created with. */
+/// Gets the context that a location was created with.
 MlirContext mlirLocationGetContext(MlirLocation location);
 
 /** Prints a location by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
 void mlirLocationPrint(MlirLocation location, MlirStringCallback callback,
                        void *userData);
 
-/*============================================================================*/
-/* Module API.                                                                */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Module API.
+//===----------------------------------------------------------------------===//
 
-/** Creates a new, empty module and transfers ownership to the caller. */
+/// Creates a new, empty module and transfers ownership to the caller.
 MlirModule mlirModuleCreateEmpty(MlirLocation location);
 
-/** Parses a module from the string and transfers ownership to the caller. */
+/// Parses a module from the string and transfers ownership to the caller.
 MlirModule mlirModuleCreateParse(MlirContext context, const char *module);
 
-/** Gets the context that a module was created with. */
+/// Gets the context that a module was created with.
 MlirContext mlirModuleGetContext(MlirModule module);
 
-/** Gets the body of the module, i.e. the only block it contains. */
+/// Gets the body of the module, i.e. the only block it contains.
 MlirBlock mlirModuleGetBody(MlirModule module);
 
-/** Checks whether a module is null. */
+/// Checks whether a module is null.
 static inline int mlirModuleIsNull(MlirModule module) { return !module.ptr; }
 
-/** Takes a module owned by the caller and deletes it. */
+/// Takes a module owned by the caller and deletes it.
 void mlirModuleDestroy(MlirModule module);
 
-/** Views the module as a generic operation. */
+/// Views the module as a generic operation.
 MlirOperation mlirModuleGetOperation(MlirModule module);
 
-/*============================================================================*/
-/* Operation state.                                                           */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Operation state.
+//===----------------------------------------------------------------------===//
 
 /** An auxiliary class for constructing operations.
  *
  * This class contains all the information necessary to construct the operation.
  * It owns the MlirRegions it has pointers to and does not own anything else.
  * By default, the state can be constructed from a name and location, the latter
  * being also used to access the context, and has no other components. These
  * components can be added progressively until the operation is constructed.
struct MlirOperationState {
   MlirRegion *regions;
   intptr_t nSuccessors;
   MlirBlock *successors;
   intptr_t nAttributes;
   MlirNamedAttribute *attributes;
 };
 typedef struct MlirOperationState MlirOperationState;
 
-/** Constructs an operation state from a name and a location. */
+/// Constructs an operation state from a name and a location.
 MlirOperationState mlirOperationStateGet(const char *name, MlirLocation loc);
 
-/** Adds a list of components to the operation state. */
+/// Adds a list of components to the operation state.
 void mlirOperationStateAddResults(MlirOperationState *state, intptr_t n,
                                   MlirType *results);
 void mlirOperationStateAddOperands(MlirOperationState *state, intptr_t n,
                                    MlirValue *operands);
 void mlirOperationStateAddOwnedRegions(MlirOperationState *state, intptr_t n,
                                        MlirRegion *regions);
 void mlirOperationStateAddSuccessors(MlirOperationState *state, intptr_t n,
                                      MlirBlock *successors);
 void mlirOperationStateAddAttributes(MlirOperationState *state, intptr_t n,
                                      MlirNamedAttribute *attributes);
 
-/*============================================================================*/
-/* Op Printing flags API.                                                     */
-/* While many of these are simple settings that could be represented in a     */
-/* struct, they are wrapped in a heap allocated object and accessed via       */
-/* functions to maximize the possibility of compatibility over time.          */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Op Printing flags API.
+// While many of these are simple settings that could be represented in a
+// struct, they are wrapped in a heap allocated object and accessed via
+// functions to maximize the possibility of compatibility over time.
+//===----------------------------------------------------------------------===//
 
 /** Creates new printing flags with defaults, intended for customization.
  * Must be freed with a call to mlirOpPrintingFlagsDestroy(). */
 MlirOpPrintingFlags mlirOpPrintingFlagsCreate();
 
-/** Destroys printing flags created with mlirOpPrintingFlagsCreate. */
+/// Destroys printing flags created with mlirOpPrintingFlagsCreate.
 void mlirOpPrintingFlagsDestroy(MlirOpPrintingFlags flags);
 
 /** Enables the elision of large elements attributes by printing a lexically
  * valid but otherwise meaningless form instead of the element data. The
  * `largeElementLimit` is used to configure what is considered to be a "large"
  * ElementsAttr by providing an upper limit to the number of elements. */
 void mlirOpPrintingFlagsElideLargeElementsAttrs(MlirOpPrintingFlags flags,
                                                 intptr_t largeElementLimit);
 
 /** Enable printing of debug information. If 'prettyForm' is set to true,
  * debug information is printed in a more readable 'pretty' form. Note: The
  * IR generated with 'prettyForm' is not parsable. */
 void mlirOpPrintingFlagsEnableDebugInfo(MlirOpPrintingFlags flags,
                                         int prettyForm);
 
-/** Always print operations in the generic form. */
+/// Always print operations in the generic form.
 void mlirOpPrintingFlagsPrintGenericOpForm(MlirOpPrintingFlags flags);
 
 /** Use local scope when printing the operation. This allows for using the
  * printer in a more localized and thread-safe setting, but may not
  * necessarily be identical to what the IR will look like when dumping
  * the full module. */
 void mlirOpPrintingFlagsUseLocalScope(MlirOpPrintingFlags flags);
 
-/*============================================================================*/
-/* Operation API.                                                             */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Operation API.
+//===----------------------------------------------------------------------===//
 
-/** Creates an operation and transfers ownership to the caller. */
+/// Creates an operation and transfers ownership to the caller.
 MlirOperation mlirOperationCreate(const MlirOperationState *state);
 
-/** Takes an operation owned by the caller and destroys it. */
+/// Takes an operation owned by the caller and destroys it.
 void mlirOperationDestroy(MlirOperation op);
 
-/** Checks whether the underlying operation is null. */
+/// Checks whether the underlying operation is null.
 static inline int mlirOperationIsNull(MlirOperation op) { return !op.ptr; }
 
 /** Checks whether two operation handles point to the same operation. This does
  * not perform deep comparison. */
 int mlirOperationEqual(MlirOperation op, MlirOperation other);
 
-/** Gets the name of the operation as an identifier. */
+/// Gets the name of the operation as an identifier.
 MlirIdentifier mlirOperationGetName(MlirOperation op);
 
 /** Gets the block that owns this operation, returning null if the operation is
  * not owned. */
 MlirBlock mlirOperationGetBlock(MlirOperation op);
 
 /** Gets the operation that owns this operation, returning null if the operation
  * is not owned. */
 MlirOperation mlirOperationGetParentOperation(MlirOperation op);
 
-/** Returns the number of regions attached to the given operation. */
+/// Returns the number of regions attached to the given operation.
 intptr_t mlirOperationGetNumRegions(MlirOperation op);
 
-/** Returns `pos`-th region attached to the operation. */
+/// Returns `pos`-th region attached to the operation.
 MlirRegion mlirOperationGetRegion(MlirOperation op, intptr_t pos);
 
 /** Returns an operation immediately following the given operation it its
  * enclosing block. */
 MlirOperation mlirOperationGetNextInBlock(MlirOperation op);
 
-/** Returns the number of operands of the operation. */
+/// Returns the number of operands of the operation.
 intptr_t mlirOperationGetNumOperands(MlirOperation op);
 
-/** Returns `pos`-th operand of the operation. */
+/// Returns `pos`-th operand of the operation.
 MlirValue mlirOperationGetOperand(MlirOperation op, intptr_t pos);
 
-/** Returns the number of results of the operation. */
+/// Returns the number of results of the operation.
 intptr_t mlirOperationGetNumResults(MlirOperation op);
 
-/** Returns `pos`-th result of the operation. */
+/// Returns `pos`-th result of the operation.
 MlirValue mlirOperationGetResult(MlirOperation op, intptr_t pos);
 
-/** Returns the number of successor blocks of the operation. */
+/// Returns the number of successor blocks of the operation.
 intptr_t mlirOperationGetNumSuccessors(MlirOperation op);
 
-/** Returns `pos`-th successor of the operation. */
+/// Returns `pos`-th successor of the operation.
 MlirBlock mlirOperationGetSuccessor(MlirOperation op, intptr_t pos);
 
-/** Returns the number of attributes attached to the operation. */
+/// Returns the number of attributes attached to the operation.
 intptr_t mlirOperationGetNumAttributes(MlirOperation op);
 
-/** Return `pos`-th attribute of the operation. */
+/// Return `pos`-th attribute of the operation.
 MlirNamedAttribute mlirOperationGetAttribute(MlirOperation op, intptr_t pos);
 
-/** Returns an attribute attached to the operation given its name. */
+/// Returns an attribute attached to the operation given its name.
 MlirAttribute mlirOperationGetAttributeByName(MlirOperation op,
                                               const char *name);
 
 /** Sets an attribute by name, replacing the existing if it exists or
  * adding a new one otherwise. */
 void mlirOperationSetAttributeByName(MlirOperation op, const char *name,
                                      MlirAttribute attr);
 
 /** Removes an attribute by name. Returns 0 if the attribute was not found
  * and !0 if removed. */
 int mlirOperationRemoveAttributeByName(MlirOperation op, const char *name);
 
 /** Prints an operation by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
 void mlirOperationPrint(MlirOperation op, MlirStringCallback callback,
                         void *userData);
 
 /** Same as mlirOperationPrint but accepts flags controlling the printing
  * behavior. */
 void mlirOperationPrintWithFlags(MlirOperation op, MlirOpPrintingFlags flags,
                                  MlirStringCallback callback, void *userData);
 
-/** Prints an operation to stderr. */
+/// Prints an operation to stderr.
 void mlirOperationDump(MlirOperation op);
 
-/*============================================================================*/
-/* Region API.                                                                */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Region API.
+//===----------------------------------------------------------------------===//
 
-/** Creates a new empty region and transfers ownership to the caller. */
+/// Creates a new empty region and transfers ownership to the caller.
 MlirRegion mlirRegionCreate();
 
-/** Takes a region owned by the caller and destroys it. */
+/// Takes a region owned by the caller and destroys it.
 void mlirRegionDestroy(MlirRegion region);
 
-/** Checks whether a region is null. */
+/// Checks whether a region is null.
 static inline int mlirRegionIsNull(MlirRegion region) { return !region.ptr; }
 
-/** Gets the first block in the region. */
+/// Gets the first block in the region.
 MlirBlock mlirRegionGetFirstBlock(MlirRegion region);
 
-/** Takes a block owned by the caller and appends it to the given region. */
+/// Takes a block owned by the caller and appends it to the given region.
 void mlirRegionAppendOwnedBlock(MlirRegion region, MlirBlock block);
 
 /** Takes a block owned by the caller and inserts it at `pos` to the given
  * region. This is an expensive operation that linearly scans the region, prefer
  * insertAfter/Before instead. */
 void mlirRegionInsertOwnedBlock(MlirRegion region, intptr_t pos,
                                 MlirBlock block);
 
 /** Takes a block owned by the caller and inserts it after the (non-owned)
  * reference block in the given region. The reference block must belong to the
  * region. If the reference block is null, prepends the block to the region. */
 void mlirRegionInsertOwnedBlockAfter(MlirRegion region, MlirBlock reference,
                                      MlirBlock block);
 
 /** Takes a block owned by the caller and inserts it before the (non-owned)
  * reference block in the given region. The reference block must belong to the
  * region. If the reference block is null, appends the block to the region. */
 void mlirRegionInsertOwnedBlockBefore(MlirRegion region, MlirBlock reference,
                                       MlirBlock block);
 
-/*============================================================================*/
-/* Block API.                                                                 */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Block API.
+//===----------------------------------------------------------------------===//
 
 /** Creates a new empty block with the given argument types and transfers
  * ownership to the caller. */
 MlirBlock mlirBlockCreate(intptr_t nArgs, MlirType *args);
 
-/** Takes a block owned by the caller and destroys it. */
+/// Takes a block owned by the caller and destroys it.
 void mlirBlockDestroy(MlirBlock block);
 
-/** Checks whether a block is null. */
+/// Checks whether a block is null.
 static inline int mlirBlockIsNull(MlirBlock block) { return !block.ptr; }
 
 /** Checks whether two blocks handles point to the same block. This does not
  * perform deep comparison. */
 int mlirBlockEqual(MlirBlock block, MlirBlock other);
 
 /** Returns the block immediately following the given block in its parent
  * region. */
 MlirBlock mlirBlockGetNextInRegion(MlirBlock block);
 
-/** Returns the first operation in the block. */
+/// Returns the first operation in the block.
 MlirOperation mlirBlockGetFirstOperation(MlirBlock block);
 
-/** Returns the terminator operation in the block or null if no terminator. */
+/// Returns the terminator operation in the block or null if no terminator.
 MlirOperation mlirBlockGetTerminator(MlirBlock block);
 
-/** Takes an operation owned by the caller and appends it to the block. */
+/// Takes an operation owned by the caller and appends it to the block.
 void mlirBlockAppendOwnedOperation(MlirBlock block, MlirOperation operation);
 
 /** Takes an operation owned by the caller and inserts it as `pos` to the block.
    This is an expensive operation that scans the block linearly, prefer
    insertBefore/After instead. */
 void mlirBlockInsertOwnedOperation(MlirBlock block, intptr_t pos,
                                    MlirOperation operation);
 
 /** Takes an operation owned by the caller and inserts it after the (non-owned)
  * reference operation in the given block. If the reference is null, prepends
  * the operation. Otherwise, the reference must belong to the block. */
 void mlirBlockInsertOwnedOperationAfter(MlirBlock block,
                                         MlirOperation reference,
                                         MlirOperation operation);
 
 /** Takes an operation owned by the caller and inserts it before the (non-owned)
  * reference operation in the given block. If the reference is null, appends the
  * operation. Otherwise, the reference must belong to the block. */
 void mlirBlockInsertOwnedOperationBefore(MlirBlock block,
                                          MlirOperation reference,
                                          MlirOperation operation);
 
-/** Returns the number of arguments of the block. */
+/// Returns the number of arguments of the block.
 intptr_t mlirBlockGetNumArguments(MlirBlock block);
 
-/** Returns `pos`-th argument of the block. */
+/// Returns `pos`-th argument of the block.
 MlirValue mlirBlockGetArgument(MlirBlock block, intptr_t pos);
 
 /** Prints a block by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
 void mlirBlockPrint(MlirBlock block, MlirStringCallback callback,
                     void *userData);
 
-/*============================================================================*/
-/* Value API.                                                                 */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Value API.
+//===----------------------------------------------------------------------===//
 
-/** Returns whether the value is null. */
+/// Returns whether the value is null.
 static inline int mlirValueIsNull(MlirValue value) { return !value.ptr; }
 
-/** Returns 1 if the value is a block argument, 0 otherwise. */
+/// Returns 1 if the value is a block argument, 0 otherwise.
 int mlirValueIsABlockArgument(MlirValue value);
 
-/** Returns 1 if the value is an operation result, 0 otherwise. */
+/// Returns 1 if the value is an operation result, 0 otherwise.
 int mlirValueIsAOpResult(MlirValue value);
 
 /** Returns the block in which this value is defined as an argument. Asserts if
  * the value is not a block argument. */
 MlirBlock mlirBlockArgumentGetOwner(MlirValue value);
 
-/** Returns the position of the value in the argument list of its block. */
+/// Returns the position of the value in the argument list of its block.
 intptr_t mlirBlockArgumentGetArgNumber(MlirValue value);
 
-/** Sets the type of the block argument to the given type. */
+/// Sets the type of the block argument to the given type.
 void mlirBlockArgumentSetType(MlirValue value, MlirType type);
 
 /** Returns an operation that produced this value as its result. Asserts if the
  * value is not an op result. */
 MlirOperation mlirOpResultGetOwner(MlirValue value);
 
 /** Returns the position of the value in the list of results of the operation
  * that produced it. */
 intptr_t mlirOpResultGetResultNumber(MlirValue value);
 
-/** Returns the type of the value. */
+/// Returns the type of the value.
 MlirType mlirValueGetType(MlirValue value);
 
-/** Prints the value to the standard error stream. */
+/// Prints the value to the standard error stream.
 void mlirValueDump(MlirValue value);
 
 /** Prints a value by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
 void mlirValuePrint(MlirValue value, MlirStringCallback callback,
                     void *userData);
 
-/*============================================================================*/
-/* Type API.                                                                  */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Type API.
+//===----------------------------------------------------------------------===//
 
-/** Parses a type. The type is owned by the context. */
+/// Parses a type. The type is owned by the context.
 MlirType mlirTypeParseGet(MlirContext context, const char *type);
 
-/** Gets the context that a type was created with. */
+/// Gets the context that a type was created with.
 MlirContext mlirTypeGetContext(MlirType type);
 
-/** Checks whether a type is null. */
+/// Checks whether a type is null.
 static inline int mlirTypeIsNull(MlirType type) { return !type.ptr; }
 
-/** Checks if two types are equal. */
+/// Checks if two types are equal.
 int mlirTypeEqual(MlirType t1, MlirType t2);
 
 /** Prints a location by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
 void mlirTypePrint(MlirType type, MlirStringCallback callback, void *userData);
 
-/** Prints the type to the standard error stream. */
+/// Prints the type to the standard error stream.
 void mlirTypeDump(MlirType type);
 
-/*============================================================================*/
-/* Attribute API.                                                             */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Attribute API.
+//===----------------------------------------------------------------------===//
 
-/** Parses an attribute. The attribute is owned by the context. */
+/// Parses an attribute. The attribute is owned by the context.
 MlirAttribute mlirAttributeParseGet(MlirContext context, const char *attr);
 
-/** Gets the context that an attribute was created with. */
+/// Gets the context that an attribute was created with.
 MlirContext mlirAttributeGetContext(MlirAttribute attribute);
 
-/** Gets the type of this attribute. */
+/// Gets the type of this attribute.
 MlirType mlirAttributeGetType(MlirAttribute attribute);
 
-/** Checks whether an attribute is null. */
+/// Checks whether an attribute is null.
 static inline int mlirAttributeIsNull(MlirAttribute attr) { return !attr.ptr; }
 
-/** Checks if two attributes are equal. */
+/// Checks if two attributes are equal.
 int mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2);
 
 /** Prints an attribute by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
 void mlirAttributePrint(MlirAttribute attr, MlirStringCallback callback,
                         void *userData);
 
-/** Prints the attribute to the standard error stream. */
+/// Prints the attribute to the standard error stream.
 void mlirAttributeDump(MlirAttribute attr);
 
-/** Associates an attribute with the name. Takes ownership of neither. */
+/// Associates an attribute with the name. Takes ownership of neither.
 MlirNamedAttribute mlirNamedAttributeGet(const char *name, MlirAttribute attr);
 
-/*============================================================================*/
-/* Identifier API.                                                            */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Identifier API.
+//===----------------------------------------------------------------------===//
 
-/** Gets an identifier with the given string value. */
+/// Gets an identifier with the given string value.
 MlirIdentifier mlirIdentifierGet(MlirContext context, MlirStringRef str);
 
-/** Checks whether two identifiers are the same. */
+/// Checks whether two identifiers are the same.
 int mlirIdentifierEqual(MlirIdentifier ident, MlirIdentifier other);
 
-/** Gets the string value of the identifier. */
+/// Gets the string value of the identifier.
 MlirStringRef mlirIdentifierStr(MlirIdentifier ident);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_IR_H

mlir/include/mlir-c/Pass.h

-/*===-- mlir-c/Pass.h - C API to Pass Management ------------------*- 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 header declares the C interface to MLIR pass manager.                 *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
+//===-- mlir-c/Pass.h - C API to Pass Management ------------------*- 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 header declares the C interface to MLIR pass manager.
+//
+//===----------------------------------------------------------------------===//
 
 #ifndef MLIR_C_PASS_H
 #define MLIR_C_PASS_H
 
 #include "mlir-c/IR.h"
 #include "mlir-c/Support.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
 /** Opaque type declarations.
  *
  * Types are exposed to C bindings as structs containing opaque pointers. They
  * are not supposed to be inspected from C. This allows the underlying
  * representation to change without affecting the API users. The use of structs
  * instead of typedefs enables some type safety as structs are not implicitly
  * convertible to each other.
  *
  * Instances of these types may or may not own the underlying object. The
  * ownership semantics is defined by how an instance of the type was obtained.
  */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
 
 #define DEFINE_C_API_STRUCT(name, storage)                                     \
   struct name {                                                                \
     storage *ptr;                                                              \
   };                                                                           \
   typedef struct name name
 
 DEFINE_C_API_STRUCT(MlirPass, void);
 DEFINE_C_API_STRUCT(MlirPassManager, void);
 DEFINE_C_API_STRUCT(MlirOpPassManager, void);
 
 #undef DEFINE_C_API_STRUCT
 
-/** Create a new top-level PassManager. */
+/// Create a new top-level PassManager.
 MlirPassManager mlirPassManagerCreate(MlirContext ctx);
 
-/** Destroy the provided PassManager. */
+/// Destroy the provided PassManager.
 void mlirPassManagerDestroy(MlirPassManager passManager);
 
-/** Cast a top-level PassManager to a generic OpPassManager. */
+/// Cast a top-level PassManager to a generic OpPassManager.
 MlirOpPassManager
 mlirPassManagerGetAsOpPassManager(MlirPassManager passManager);
 
-/** Run the provided `passManager` on the given `module`. */
+/// Run the provided `passManager` on the given `module`.
 MlirLogicalResult mlirPassManagerRun(MlirPassManager passManager,
                                      MlirModule module);
 
 /** Nest an OpPassManager under the top-level PassManager, the nested
  * passmanager will only run on operations matching the provided name.
  * The returned OpPassManager will be destroyed when the parent is destroyed.
  * To further nest more OpPassManager under the newly returned one, see
  * `mlirOpPassManagerNest` below. */

mlir/include/mlir-c/Registration.h

-/*===-- mlir-c/Registration.h - Registration functions for MLIR ---*- 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                    *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
+//===-- mlir-c/Registration.h - Registration functions for MLIR ---*- 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_C_REGISTRATION_H
 #define MLIR_C_REGISTRATION_H
 
 #include "mlir-c/IR.h"
 
 #ifdef __cplusplus
 extern "C" {

mlir/include/mlir-c/StandardAttributes.h

-/*===-- mlir-c/StandardAttributes.h - C API for Std Attributes-----*- 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 header declares the C interface to MLIR Standard attributes.          *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
+//===-- mlir-c/StandardAttributes.h - C API for Std Attributes-----*- 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 header declares the C interface to MLIR Standard attributes.
+//
+//===----------------------------------------------------------------------===//
 
 #ifndef MLIR_C_STANDARDATTRIBUTES_H
 #define MLIR_C_STANDARDATTRIBUTES_H
 
 #include "mlir-c/AffineMap.h"
 #include "mlir-c/IR.h"
 #include "mlir-c/Support.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/*============================================================================*/
-/* Affine map attribute.                                                      */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine map attribute.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given attribute is an affine map attribute. */
+/// Checks whether the given attribute is an affine map attribute.
 int mlirAttributeIsAAffineMap(MlirAttribute attr);
 
 /** Creates an affine map attribute wrapping the given map. The attribute
  * belongs to the same context as the affine map. */
 MlirAttribute mlirAffineMapAttrGet(MlirAffineMap map);
 
-/** Returns the affine map wrapped in the given affine map attribute. */
+/// Returns the affine map wrapped in the given affine map attribute.
 MlirAffineMap mlirAffineMapAttrGetValue(MlirAttribute attr);
 
-/*============================================================================*/
-/* Array attribute.                                                           */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Array attribute.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given attribute is an array attribute. */
+/// Checks whether the given attribute is an array attribute.
 int mlirAttributeIsAArray(MlirAttribute attr);
 
 /** Creates an array element containing the given list of elements in the given
  * context. */
 MlirAttribute mlirArrayAttrGet(MlirContext ctx, intptr_t numElements,
                                MlirAttribute *elements);
 
-/** Returns the number of elements stored in the given array attribute. */
+/// Returns the number of elements stored in the given array attribute.
 intptr_t mlirArrayAttrGetNumElements(MlirAttribute attr);
 
-/** Returns pos-th element stored in the given array attribute. */
+/// Returns pos-th element stored in the given array attribute.
 MlirAttribute mlirArrayAttrGetElement(MlirAttribute attr, intptr_t pos);
 
-/*============================================================================*/
-/* Dictionary attribute.                                                      */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Dictionary attribute.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given attribute is a dictionary attribute. */
+/// Checks whether the given attribute is a dictionary attribute.
 int mlirAttributeIsADictionary(MlirAttribute attr);
 
 /** Creates a dictionary attribute containing the given list of elements in the
  * provided context. */
 MlirAttribute mlirDictionaryAttrGet(MlirContext ctx, intptr_t numElements,
                                     MlirNamedAttribute *elements);
 
-/** Returns the number of attributes contained in a dictionary attribute. */
+/// Returns the number of attributes contained in a dictionary attribute.
 intptr_t mlirDictionaryAttrGetNumElements(MlirAttribute attr);
 
-/** Returns pos-th element of the given dictionary attribute. */
+/// Returns pos-th element of the given dictionary attribute.
 MlirNamedAttribute mlirDictionaryAttrGetElement(MlirAttribute attr,
                                                 intptr_t pos);
 
 /** Returns the dictionary attribute element with the given name or NULL if the
  * given name does not exist in the dictionary. */
 MlirAttribute mlirDictionaryAttrGetElementByName(MlirAttribute attr,
                                                  const char *name);
 
-/*============================================================================*/
-/* Floating point attribute.                                                  */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Floating point attribute.
+//===----------------------------------------------------------------------===//
 
 /* TODO: add support for APFloat and APInt to LLVM IR C API, then expose the
  * relevant functions here. */
 
-/** Checks whether the given attribute is a floating point attribute. */
+/// Checks whether the given attribute is a floating point attribute.
 int mlirAttributeIsAFloat(MlirAttribute attr);
 
 /** Creates a floating point attribute in the given context with the given
  * double value and double-precision FP semantics. */
 MlirAttribute mlirFloatAttrDoubleGet(MlirContext ctx, MlirType type,
                                      double value);
 
 /** Same as "mlirFloatAttrDoubleGet", but if the type is not valid for a
  * construction of a FloatAttr, returns a null MlirAttribute. */
 MlirAttribute mlirFloatAttrDoubleGetChecked(MlirType type, double value,
                                             MlirLocation loc);
 
 /** Returns the value stored in the given floating point attribute, interpreting
  * the value as double. */
 double mlirFloatAttrGetValueDouble(MlirAttribute attr);
 
-/*============================================================================*/
-/* Integer attribute.                                                         */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Integer attribute.
+//===----------------------------------------------------------------------===//
 
 /* TODO: add support for APFloat and APInt to LLVM IR C API, then expose the
  * relevant functions here. */
 
-/** Checks whether the given attribute is an integer attribute. */
+/// Checks whether the given attribute is an integer attribute.
 int mlirAttributeIsAInteger(MlirAttribute attr);
 
 /** Creates an integer attribute of the given type with the given integer
  * value. */
 MlirAttribute mlirIntegerAttrGet(MlirType type, int64_t value);
 
 /** Returns the value stored in the given integer attribute, assuming the value
  * fits into a 64-bit integer. */
 int64_t mlirIntegerAttrGetValueInt(MlirAttribute attr);
 
-/*============================================================================*/
-/* Bool attribute.                                                            */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Bool attribute.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given attribute is a bool attribute. */
+/// Checks whether the given attribute is a bool attribute.
 int mlirAttributeIsABool(MlirAttribute attr);
 
-/** Creates a bool attribute in the given context with the given value. */
+/// Creates a bool attribute in the given context with the given value.
 MlirAttribute mlirBoolAttrGet(MlirContext ctx, int value);
 
-/** Returns the value stored in the given bool attribute. */
+/// Returns the value stored in the given bool attribute.
 int mlirBoolAttrGetValue(MlirAttribute attr);
 
-/*============================================================================*/
-/* Integer set attribute.                                                     */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Integer set attribute.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given attribute is an integer set attribute. */
+/// Checks whether the given attribute is an integer set attribute.
 int mlirAttributeIsAIntegerSet(MlirAttribute attr);
 
-/*============================================================================*/
-/* Opaque attribute.                                                          */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Opaque attribute.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given attribute is an opaque attribute. */
+/// Checks whether the given attribute is an opaque attribute.
 int mlirAttributeIsAOpaque(MlirAttribute attr);
 
 /** Creates an opaque attribute in the given context associated with the dialect
  * identified by its namespace. The attribute contains opaque byte data of the
  * specified length (data need not be null-terminated). */
 MlirAttribute mlirOpaqueAttrGet(MlirContext ctx, const char *dialectNamespace,
                                 intptr_t dataLength, const char *data,
                                 MlirType type);
 
 /** Returns the namespace of the dialect with which the given opaque attribute
  * is associated. The namespace string is owned by the context. */
 const char *mlirOpaqueAttrGetDialectNamespace(MlirAttribute attr);
 
 /** Returns the raw data as a string reference. The data remains live as long as
  * the context in which the attribute lives. */
 MlirStringRef mlirOpaqueAttrGetData(MlirAttribute attr);
 
-/*============================================================================*/
-/* String attribute.                                                          */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// String attribute.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given attribute is a string attribute. */
+/// Checks whether the given attribute is a string attribute.
 int mlirAttributeIsAString(MlirAttribute attr);
 
 /** Creates a string attribute in the given context containing the given string.
  * The string need not be null-terminated and its length must be specified. */
 MlirAttribute mlirStringAttrGet(MlirContext ctx, intptr_t length,
                                 const char *data);
 
 /** Creates a string attribute in the given context containing the given string.
  * The string need not be null-terminated and its length must be specified.
  * Additionally, the attribute has the given type. */
 MlirAttribute mlirStringAttrTypedGet(MlirType type, intptr_t length,
                                      const char *data);
 
 /** Returns the attribute values as a string reference. The data remains live as
  * long as the context in which the attribute lives. */
 MlirStringRef mlirStringAttrGetValue(MlirAttribute attr);
 
-/*============================================================================*/
-/* SymbolRef attribute.                                                       */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// SymbolRef attribute.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given attribute is a symbol reference attribute. */
+/// Checks whether the given attribute is a symbol reference attribute.
 int mlirAttributeIsASymbolRef(MlirAttribute attr);
 
 /** Creates a symbol reference attribute in the given context referencing a
  * symbol identified by the given string inside a list of nested references.
  * Each of the references in the list must not be nested. The string need not be
  * null-terminated and its length must be specified. */
 MlirAttribute mlirSymbolRefAttrGet(MlirContext ctx, intptr_t length,
                                    const char *symbol, intptr_t numReferences,
                                    MlirAttribute *references);
 
 /** Returns the string reference to the root referenced symbol. The data remains
  * live as long as the context in which the attribute lives. */
 MlirStringRef mlirSymbolRefAttrGetRootReference(MlirAttribute attr);
 
 /** Returns the string reference to the leaf referenced symbol. The data remains
  * live as long as the context in which the attribute lives. */
 MlirStringRef mlirSymbolRefAttrGetLeafReference(MlirAttribute attr);
 
 /** Returns the number of references nested in the given symbol reference
  * attribute. */
 intptr_t mlirSymbolRefAttrGetNumNestedReferences(MlirAttribute attr);
 
-/** Returns pos-th reference nested in the given symbol reference attribute. */
+/// Returns pos-th reference nested in the given symbol reference attribute.
 MlirAttribute mlirSymbolRefAttrGetNestedReference(MlirAttribute attr,
                                                   intptr_t pos);
 
-/*============================================================================*/
-/* Flat SymbolRef attribute.                                                  */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Flat SymbolRef attribute.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given attribute is a flat symbol reference attribute. */
+/// Checks whether the given attribute is a flat symbol reference attribute.
 int mlirAttributeIsAFlatSymbolRef(MlirAttribute attr);
 
 /** Creates a flat symbol reference attribute in the given context referencing a
  * symbol identified by the given string. The string need not be null-terminated
  * and its length must be specified. */
 MlirAttribute mlirFlatSymbolRefAttrGet(MlirContext ctx, intptr_t length,
                                        const char *symbol);
 
 /** Returns the referenced symbol as a string reference. The data remains live
  * as long as the context in which the attribute lives. */
 MlirStringRef mlirFlatSymbolRefAttrGetValue(MlirAttribute attr);
 
-/*============================================================================*/
-/* Type attribute.                                                            */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Type attribute.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given attribute is a type attribute. */
+/// Checks whether the given attribute is a type attribute.
 int mlirAttributeIsAType(MlirAttribute attr);
 
 /** Creates a type attribute wrapping the given type in the same context as the
  * type. */
 MlirAttribute mlirTypeAttrGet(MlirType type);
 
-/** Returns the type stored in the given type attribute. */
+/// Returns the type stored in the given type attribute.
 MlirType mlirTypeAttrGetValue(MlirAttribute attr);
 
-/*============================================================================*/
-/* Unit attribute.                                                            */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Unit attribute.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given attribute is a unit attribute. */
+/// Checks whether the given attribute is a unit attribute.
 int mlirAttributeIsAUnit(MlirAttribute attr);
 
-/** Creates a unit attribute in the given context. */
+/// Creates a unit attribute in the given context.
 MlirAttribute mlirUnitAttrGet(MlirContext ctx);
 
-/*============================================================================*/
-/* Elements attributes.                                                       */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Elements attributes.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given attribute is an elements attribute. */
+/// Checks whether the given attribute is an elements attribute.
 int mlirAttributeIsAElements(MlirAttribute attr);
 
-/** Returns the element at the given rank-dimensional index. */
+/// Returns the element at the given rank-dimensional index.
 MlirAttribute mlirElementsAttrGetValue(MlirAttribute attr, intptr_t rank,
                                        uint64_t *idxs);
 
 /** Checks whether the given rank-dimensional index is valid in the given
  * elements attribute. */
 int mlirElementsAttrIsValidIndex(MlirAttribute attr, intptr_t rank,
                                  uint64_t *idxs);
 
 /** Gets the total number of elements in the given elements attribute. In order
  * to iterate over the attribute, obtain its type, which must be a statically
  * shaped type and use its sizes to build a multi-dimensional index. */
 int64_t mlirElementsAttrGetNumElements(MlirAttribute attr);
 
-/*============================================================================*/
-/* Dense elements attribute.                                                  */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Dense elements attribute.
+//===----------------------------------------------------------------------===//
 
-/* TODO: decide on the interface and add support for complex elements. */
+// TODO: decide on the interface and add support for complex elements.
 /* TODO: add support for APFloat and APInt to LLVM IR C API, then expose the
  * relevant functions here. */
 
-/** Checks whether the given attribute is a dense elements attribute. */
+/// Checks whether the given attribute is a dense elements attribute.
 int mlirAttributeIsADenseElements(MlirAttribute attr);
 int mlirAttributeIsADenseIntElements(MlirAttribute attr);
 int mlirAttributeIsADenseFPElements(MlirAttribute attr);
 
 /** Creates a dense elements attribute with the given Shaped type and elements
  * in the same context as the type. */
 MlirAttribute mlirDenseElementsAttrGet(MlirType shapedType,
                                        intptr_t numElements,

 uint32_t mlirDenseElementsAttrGetUInt32Value(MlirAttribute attr, intptr_t pos);
 int64_t mlirDenseElementsAttrGetInt64Value(MlirAttribute attr, intptr_t pos);
 uint64_t mlirDenseElementsAttrGetUInt64Value(MlirAttribute attr, intptr_t pos);
 float mlirDenseElementsAttrGetFloatValue(MlirAttribute attr, intptr_t pos);
 double mlirDenseElementsAttrGetDoubleValue(MlirAttribute attr, intptr_t pos);
 MlirStringRef mlirDenseElementsAttrGetStringValue(MlirAttribute attr,
                                                   intptr_t pos);
 
-/*============================================================================*/
-/* Opaque elements attribute.                                                 */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Opaque elements attribute.
+//===----------------------------------------------------------------------===//
 
-/* TODO: expose Dialect to the bindings and implement accessors here. */
+// TODO: expose Dialect to the bindings and implement accessors here.
 
-/** Checks whether the given attribute is an opaque elements attribute. */
+/// Checks whether the given attribute is an opaque elements attribute.
 int mlirAttributeIsAOpaqueElements(MlirAttribute attr);
 
-/*============================================================================*/
-/* Sparse elements attribute.                                                 */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Sparse elements attribute.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given attribute is a sparse elements attribute. */
+/// Checks whether the given attribute is a sparse elements attribute.
 int mlirAttributeIsASparseElements(MlirAttribute attr);
 
 /** Creates a sparse elements attribute of the given shape from a list of
  * indices and a list of associated values. Both lists are expected to be dense
  * elements attributes with the same number of elements. The list of indices is
  * expected to contain 64-bit integers. The attribute is created in the same
  * context as the type. */
 MlirAttribute mlirSparseElementsAttribute(MlirType shapedType,

mlir/include/mlir-c/StandardDialect.h

-/*===-- mlir-c/StandardDialect.h - C API for Standard 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 header declares the C interface for registering and accessing the     *|
-|* Standard dialect. A dialect should be registered with a context to make it *|
-|* available to users of the context. These users must load the dialect       *|
-|* before using any of its attributes, operations or types. Parser and pass   *|
-|* manager can load registered dialects automatically.                        *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
+//===-- mlir-c/StandardDialect.h - C API for Standard 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 header declares the C interface for registering and accessing the
+// Standard dialect. A dialect should be registered with a context to make it
+// available to users of the context. These users must load the dialect
+// before using any of its attributes, operations or types. Parser and pass
+// manager can load registered dialects automatically.
+//
+//===----------------------------------------------------------------------===//
 
 #ifndef MLIR_C_STANDARDDIALECT_H
 #define MLIR_C_STANDARDDIALECT_H
 
 #include "mlir-c/IR.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /** Registers the Standard dialect with the given context. This allows the
  * dialect to be loaded dynamically if needed when parsing. */
 void mlirContextRegisterStandardDialect(MlirContext context);
 
 /** Loads the Standard dialect into the given context. The dialect does _not_
  * have to be registered in advance. */
 MlirDialect mlirContextLoadStandardDialect(MlirContext context);
 
-/** Returns the namespace of the Standard dialect, suitable for loading it. */
+/// Returns the namespace of the Standard dialect, suitable for loading it.
 MlirStringRef mlirStandardDialectGetNamespace();
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_STANDARDDIALECT_H

mlir/include/mlir-c/StandardTypes.h

-/*===-- mlir-c/StandardTypes.h - C API for MLIR Standard types ----*- 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                    *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
+//===-- mlir-c/StandardTypes.h - C API for MLIR Standard types ----*- 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_C_STANDARDTYPES_H
 #define MLIR_C_STANDARDTYPES_H
 
 #include "mlir-c/AffineMap.h"
 #include "mlir-c/IR.h"
 #include <stdint.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/*============================================================================*/
-/* Integer types.                                                             */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Integer types.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given type is an integer type. */
+/// Checks whether the given type is an integer type.
 int mlirTypeIsAInteger(MlirType type);
 
 /** Creates a signless integer type of the given bitwidth in the context. The
  * type is owned by the context. */
 MlirType mlirIntegerTypeGet(MlirContext ctx, unsigned bitwidth);
 
 /** Creates a signed integer type of the given bitwidth in the context. The type
  * is owned by the context. */
 MlirType mlirIntegerTypeSignedGet(MlirContext ctx, unsigned bitwidth);
 
 /** Creates an unsigned integer type of the given bitwidth in the context. The
  * type is owned by the context. */
 MlirType mlirIntegerTypeUnsignedGet(MlirContext ctx, unsigned bitwidth);
 
-/** Returns the bitwidth of an integer type. */
+/// Returns the bitwidth of an integer type.
 unsigned mlirIntegerTypeGetWidth(MlirType type);
 
-/** Checks whether the given integer type is signless. */
+/// Checks whether the given integer type is signless.
 int mlirIntegerTypeIsSignless(MlirType type);
 
-/** Checks whether the given integer type is signed. */
+/// Checks whether the given integer type is signed.
 int mlirIntegerTypeIsSigned(MlirType type);
 
-/** Checks whether the given integer type is unsigned. */
+/// Checks whether the given integer type is unsigned.
 int mlirIntegerTypeIsUnsigned(MlirType type);
 
-/*============================================================================*/
-/* Index type.                                                                */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Index type.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given type is an index type. */
+/// Checks whether the given type is an index type.
 int mlirTypeIsAIndex(MlirType type);
 
 /** Creates an index type in the given context. The type is owned by the
  * context. */
 MlirType mlirIndexTypeGet(MlirContext ctx);
 
-/*============================================================================*/
-/* Floating-point types.                                                      */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Floating-point types.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given type is a bf16 type. */
+/// Checks whether the given type is a bf16 type.
 int mlirTypeIsABF16(MlirType type);
 
 /** Creates a bf16 type in the given context. The type is owned by the
  * context. */
 MlirType mlirBF16TypeGet(MlirContext ctx);
 
-/** Checks whether the given type is an f16 type. */
+/// Checks whether the given type is an f16 type.
 int mlirTypeIsAF16(MlirType type);
 
 /** Creates an f16 type in the given context. The type is owned by the
  * context. */
 MlirType mlirF16TypeGet(MlirContext ctx);
 
-/** Checks whether the given type is an f32 type. */
+/// Checks whether the given type is an f32 type.
 int mlirTypeIsAF32(MlirType type);
 
 /** Creates an f32 type in the given context. The type is owned by the
  * context. */
 MlirType mlirF32TypeGet(MlirContext ctx);
 
-/** Checks whether the given type is an f64 type. */
+/// Checks whether the given type is an f64 type.
 int mlirTypeIsAF64(MlirType type);
 
 /** Creates a f64 type in the given context. The type is owned by the
  * context. */
 MlirType mlirF64TypeGet(MlirContext ctx);
 
-/*============================================================================*/
-/* None type.                                                                 */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// None type.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given type is a None type. */
+/// Checks whether the given type is a None type.
 int mlirTypeIsANone(MlirType type);
 
 /** Creates a None type in the given context. The type is owned by the
  * context. */
 MlirType mlirNoneTypeGet(MlirContext ctx);
 
-/*============================================================================*/
-/* Complex type.                                                              */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Complex type.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given type is a Complex type. */
+/// Checks whether the given type is a Complex type.
 int mlirTypeIsAComplex(MlirType type);
 
 /** Creates a complex type with the given element type in the same context as
  * the element type. The type is owned by the context. */
 MlirType mlirComplexTypeGet(MlirType elementType);
 
-/** Returns the element type of the given complex type. */
+/// Returns the element type of the given complex type.
 MlirType mlirComplexTypeGetElementType(MlirType type);
 
-/*============================================================================*/
-/* Shaped type.                                                               */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Shaped type.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given type is a Shaped type. */
+/// Checks whether the given type is a Shaped type.
 int mlirTypeIsAShaped(MlirType type);
 
-/** Returns the element type of the shaped type. */
+/// Returns the element type of the shaped type.
 MlirType mlirShapedTypeGetElementType(MlirType type);
 
-/** Checks whether the given shaped type is ranked. */
+/// Checks whether the given shaped type is ranked.
 int mlirShapedTypeHasRank(MlirType type);
 
-/** Returns the rank of the given ranked shaped type. */
+/// Returns the rank of the given ranked shaped type.
 int64_t mlirShapedTypeGetRank(MlirType type);
 
-/** Checks whether the given shaped type has a static shape. */
+/// Checks whether the given shaped type has a static shape.
 int mlirShapedTypeHasStaticShape(MlirType type);
 
-/** Checks wither the dim-th dimension of the given shaped type is dynamic. */
+/// Checks wither the dim-th dimension of the given shaped type is dynamic.
 int mlirShapedTypeIsDynamicDim(MlirType type, intptr_t dim);
 
-/** Returns the dim-th dimension of the given ranked shaped type. */
+/// Returns the dim-th dimension of the given ranked shaped type.
 int64_t mlirShapedTypeGetDimSize(MlirType type, intptr_t dim);
 
 /** Checks whether the given value is used as a placeholder for dynamic sizes
  * in shaped types. */
 int mlirShapedTypeIsDynamicSize(int64_t size);
 
 /** Checks whether the given value is used as a placeholder for dynamic strides
  * and offsets in shaped types. */
 int mlirShapedTypeIsDynamicStrideOrOffset(int64_t val);
 
-/*============================================================================*/
-/* Vector type.                                                               */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Vector type.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given type is a Vector type. */
+/// Checks whether the given type is a Vector type.
 int mlirTypeIsAVector(MlirType type);
 
 /** Creates a vector type of the shape identified by its rank and dimensions,
  * with the given element type in the same context as the element type. The type
  * is owned by the context. */
 MlirType mlirVectorTypeGet(intptr_t rank, int64_t *shape, MlirType elementType);
 
 /** Same as "mlirVectorTypeGet" but returns a nullptr wrapping MlirType on
  * illegal arguments, emitting appropriate diagnostics. */
 MlirType mlirVectorTypeGetChecked(intptr_t rank, int64_t *shape,
                                   MlirType elementType, MlirLocation loc);
 
-/*============================================================================*/
-/* Ranked / Unranked Tensor type.                                             */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Ranked / Unranked Tensor type.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given type is a Tensor type. */
+/// Checks whether the given type is a Tensor type.
 int mlirTypeIsATensor(MlirType type);
 
-/** Checks whether the given type is a ranked tensor type. */
+/// Checks whether the given type is a ranked tensor type.
 int mlirTypeIsARankedTensor(MlirType type);
 
-/** Checks whether the given type is an unranked tensor type. */
+/// Checks whether the given type is an unranked tensor type.
 int mlirTypeIsAUnrankedTensor(MlirType type);
 
 /** Creates a tensor type of a fixed rank with the given shape and element type
  * in the same context as the element type. The type is owned by the context. */
 MlirType mlirRankedTensorTypeGet(intptr_t rank, int64_t *shape,
                                  MlirType elementType);
 
 /** Same as "mlirRankedTensorTypeGet" but returns a nullptr wrapping MlirType on
  * illegal arguments, emitting appropriate diagnostics. */
 MlirType mlirRankedTensorTypeGetChecked(intptr_t rank, int64_t *shape,
                                         MlirType elementType, MlirLocation loc);
 
 /** Creates an unranked tensor type with the given element type in the same
  * context as the element type. The type is owned by the context. */
 MlirType mlirUnrankedTensorTypeGet(MlirType elementType);
 
 /** Same as "mlirUnrankedTensorTypeGet" but returns a nullptr wrapping MlirType
  * on illegal arguments, emitting appropriate diagnostics. */
 MlirType mlirUnrankedTensorTypeGetChecked(MlirType elementType,
                                           MlirLocation loc);
 
-/*============================================================================*/
-/* Ranked / Unranked MemRef type.                                             */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Ranked / Unranked MemRef type.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given type is a MemRef type. */
+/// Checks whether the given type is a MemRef type.
 int mlirTypeIsAMemRef(MlirType type);
 
-/** Checks whether the given type is an UnrankedMemRef type. */
+/// Checks whether the given type is an UnrankedMemRef type.
 int mlirTypeIsAUnrankedMemRef(MlirType type);
 
 /** Creates a MemRef type with the given rank and shape, a potentially empty
  * list of affine layout maps, the given memory space and element type, in the
  * same context as element type. The type is owned by the context. */
 MlirType mlirMemRefTypeGet(MlirType elementType, intptr_t rank, int64_t *shape,
                            intptr_t numMaps, MlirAttribute *affineMaps,
                            unsigned memorySpace);

 MlirType mlirUnrankedMemRefTypeGet(MlirType elementType, unsigned memorySpace);
 
 /** Same as "mlirUnrankedMemRefTypeGet" but returns a nullptr wrapping
  * MlirType on illegal arguments, emitting appropriate diagnostics. */
 MlirType mlirUnrankedMemRefTypeGetChecked(MlirType elementType,
                                           unsigned memorySpace,
                                           MlirLocation loc);
 
-/** Returns the number of affine layout maps in the given MemRef type. */
+/// Returns the number of affine layout maps in the given MemRef type.
 intptr_t mlirMemRefTypeGetNumAffineMaps(MlirType type);
 
-/** Returns the pos-th affine map of the given MemRef type. */
+/// Returns the pos-th affine map of the given MemRef type.
 MlirAffineMap mlirMemRefTypeGetAffineMap(MlirType type, intptr_t pos);
 
-/** Returns the memory space of the given MemRef type. */
+/// Returns the memory space of the given MemRef type.
 unsigned mlirMemRefTypeGetMemorySpace(MlirType type);
 
-/** Returns the memory spcae of the given Unranked MemRef type. */
+/// Returns the memory spcae of the given Unranked MemRef type.
 unsigned mlirUnrankedMemrefGetMemorySpace(MlirType type);
 
-/*============================================================================*/
-/* Tuple type.                                                                */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Tuple type.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given type is a tuple type. */
+/// Checks whether the given type is a tuple type.
 int mlirTypeIsATuple(MlirType type);
 
 /** Creates a tuple type that consists of the given list of elemental types. The
  * type is owned by the context. */
 MlirType mlirTupleTypeGet(MlirContext ctx, intptr_t numElements,
                           MlirType *elements);
 
-/** Returns the number of types contained in a tuple. */
+/// Returns the number of types contained in a tuple.
 intptr_t mlirTupleTypeGetNumTypes(MlirType type);
 
-/** Returns the pos-th type in the tuple type. */
+/// Returns the pos-th type in the tuple type.
 MlirType mlirTupleTypeGetType(MlirType type, intptr_t pos);
 
-/*============================================================================*/
-/* Function type.                                                             */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Function type.
+//===----------------------------------------------------------------------===//
 
-/** Checks whether the given type is a function type. */
+/// Checks whether the given type is a function type.
 int mlirTypeIsAFunction(MlirType type);
 
-/** Creates a function type, mapping a list of input types to result types. */
+/// Creates a function type, mapping a list of input types to result types.
 MlirType mlirFunctionTypeGet(MlirContext ctx, intptr_t numInputs,
                              MlirType *inputs, intptr_t numResults,
                              MlirType *results);
 
-/** Returns the number of input types. */
+/// Returns the number of input types.
 intptr_t mlirFunctionTypeGetNumInputs(MlirType type);
 
-/** Returns the number of result types. */
+/// Returns the number of result types.
 intptr_t mlirFunctionTypeGetNumResults(MlirType type);
 
-/** Returns the pos-th input type. */
+/// Returns the pos-th input type.
 MlirType mlirFunctionTypeGetInput(MlirType type, intptr_t pos);
 
-/** Returns the pos-th result type. */
+/// Returns the pos-th result type.
 MlirType mlirFunctionTypeGetResult(MlirType type, intptr_t pos);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_STANDARDTYPES_H

mlir/include/mlir-c/Support.h

-/*===-- mlir-c/Support.h - Helpers for C API to Core MLIR ---------*- 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 header declares the auxiliary data structures used in C APIs to core  *|
-|* MLIR functionality.                                                        *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
+//===-- mlir-c/Support.h - Helpers for C API to Core MLIR ---------*- 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 header declares the auxiliary data structures used in C APIs to core
+// MLIR functionality.
+//
+//===----------------------------------------------------------------------===//
 
 #ifndef MLIR_C_SUPPORT_H
 #define MLIR_C_SUPPORT_H
 
 #include <stddef.h>
 #include <stdint.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/*============================================================================*/
-/* MlirStringRef.                                                             */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// MlirStringRef.
+//===----------------------------------------------------------------------===//
 
 /** A pointer to a sized fragment of a string, not necessarily null-terminated.
  * Does not own the underlying string. This is equivalent to llvm::StringRef.
  */
 struct MlirStringRef {
   const char *data; /**< Pointer to the first symbol. */
   size_t length;    /**< Length of the fragment. */
 };
inline MlirStringRef mlirStringRefCreate(const char *str, size_t length) {
   return result;
 }
 
 /** Constructs a string reference from a null-terminated C string. Prefer
  * mlirStringRefCreate if the length of the string is known.
  */
 MlirStringRef mlirStringRefCreateFromCString(const char *str);
 
-/*============================================================================*/
-/* MlirLogicalResult.                                                         */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// MlirLogicalResult.
+//===----------------------------------------------------------------------===//
 
 /** A logical result value, essentially a boolean with named states. LLVM
  * convention for using boolean values to designate success or failure of an
  * operation is a moving target, so MLIR opted for an explicit class.
  * Instances of MlirLogicalResult must only be inspected using the associated
  * functions. */
 struct MlirLogicalResult {
   int8_t value;
 };
 typedef struct MlirLogicalResult MlirLogicalResult;
 
-/** Checks if the given logical result represents a success. */
+/// Checks if the given logical result represents a success.
 inline static int mlirLogicalResultIsSuccess(MlirLogicalResult res) {
   return res.value != 0;
 }
 
-/** Checks if the given logical result represents a failure. */
+/// Checks if the given logical result represents a failure.
 inline static int mlirLogicalResultIsFailure(MlirLogicalResult res) {
   return res.value == 0;
 }
 
-/** Creates a logical result representing a success. */
+/// Creates a logical result representing a success.
 inline static MlirLogicalResult mlirLogicalResultSuccess() {
   MlirLogicalResult res = {1};
   return res;
 }
 
-/** Creates a logical result representing a failure. */
+/// Creates a logical result representing a failure.
 inline static MlirLogicalResult mlirLogicalResultFailure() {
   MlirLogicalResult res = {0};
   return res;
 }
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_SUPPORT_H

mlir/include/mlir-c/Transforms.h

-/*===-- mlir-c/Transforms.h - Helpers for C API to Core MLIR ------*- 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 header declares the registration and creation method for              *|
-|* transformation passes.                                                     *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
+//===-- mlir-c/Transforms.h - Helpers for C API to Core MLIR ------*- 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 header declares the registration and creation method for
+// transformation passes.
+//
+//===----------------------------------------------------------------------===//
 
 #ifndef MLIR_C_TRANSFORMS_H
 #define MLIR_C_TRANSFORMS_H
 
 #include "mlir/Transforms/Transforms.capi.h.inc"
 
 #endif // MLIR_C_TRANSFORMS_H

mlir/include/mlir/CAPI/Utils.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CAPI_UTILS_H
 #define MLIR_CAPI_UTILS_H
 
 #include "llvm/Support/raw_ostream.h"
 
-/* ========================================================================== */
-/* Printing helper.                                                           */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Printing helper.
+//===----------------------------------------------------------------------===//
 
 namespace mlir {
 namespace detail {
 /// A simple raw ostream subclass that forwards write_impl calls to the
 /// user-supplied callback together with opaque user-supplied data.
 class CallbackOstream : public llvm::raw_ostream {
 public:
   CallbackOstream(std::function<void(const char *, intptr_t, void *)> callback,

mlir/include/mlir/CAPI/Wrap.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CAPI_WRAP_H
 #define MLIR_CAPI_WRAP_H
 
 #include "mlir-c/IR.h"
 #include "mlir/Support/LLVM.h"
 
-/* ========================================================================== */
-/* Definitions of methods for non-owning structures used in C API.            */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Definitions of methods for non-owning structures used in C API.
+//===----------------------------------------------------------------------===//
 
 #define DEFINE_C_API_PTR_METHODS(name, cpptype)                                \
   static inline name wrap(cpptype *cpp) { return name{cpp}; }                  \
   static inline cpptype *unwrap(name c) {                                      \
     return static_cast<cpptype *>(c.ptr);                                      \
   }
 
 #define DEFINE_C_API_METHODS(name, cpptype)                                    \

mlir/include/mlir/ExecutionEngine/AsyncRuntime.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_EXECUTIONENGINE_ASYNCRUNTIME_H_
 #define MLIR_EXECUTIONENGINE_ASYNCRUNTIME_H_
 
 #ifdef _WIN32
 #ifndef MLIR_ASYNCRUNTIME_EXPORT
 #ifdef mlir_c_runner_utils_EXPORTS
-/* We are building this library */
+// We are building this library
 #define MLIR_ASYNCRUNTIME_EXPORT __declspec(dllexport)
 #define MLIR_ASYNCRUNTIME_DEFINE_FUNCTIONS
 #else
-/* We are using this library */
+// We are using this library
 #define MLIR_ASYNCRUNTIME_EXPORT __declspec(dllimport)
 #endif // mlir_c_runner_utils_EXPORTS
 #endif // MLIR_ASYNCRUNTIME_EXPORT
 #else
 #define MLIR_ASYNCRUNTIME_EXPORT
 #define MLIR_ASYNCRUNTIME_DEFINE_FUNCTIONS
 #endif // _WIN32
 

mlir/include/mlir/ExecutionEngine/CRunnerUtils.h

 //===----------------------------------------------------------------------===//
 
 #ifndef EXECUTIONENGINE_CRUNNERUTILS_H_
 #define EXECUTIONENGINE_CRUNNERUTILS_H_
 
 #ifdef _WIN32
 #ifndef MLIR_CRUNNERUTILS_EXPORT
 #ifdef mlir_c_runner_utils_EXPORTS
-/* We are building this library */
+// We are building this library
 #define MLIR_CRUNNERUTILS_EXPORT __declspec(dllexport)
 #define MLIR_CRUNNERUTILS_DEFINE_FUNCTIONS
 #else
-/* We are using this library */
+// We are using this library
 #define MLIR_CRUNNERUTILS_EXPORT __declspec(dllimport)
 #endif // mlir_c_runner_utils_EXPORTS
 #endif // MLIR_CRUNNERUTILS_EXPORT
 #else
 #define MLIR_CRUNNERUTILS_EXPORT
 #define MLIR_CRUNNERUTILS_DEFINE_FUNCTIONS
 #endif // _WIN32
 

mlir/include/mlir/ExecutionEngine/RunnerUtils.h

 //===----------------------------------------------------------------------===//
 
 #ifndef EXECUTIONENGINE_RUNNERUTILS_H_
 #define EXECUTIONENGINE_RUNNERUTILS_H_
 
 #ifdef _WIN32
 #ifndef MLIR_RUNNERUTILS_EXPORT
 #ifdef mlir_runner_utils_EXPORTS
-/* We are building this library */
+// We are building this library
 #define MLIR_RUNNERUTILS_EXPORT __declspec(dllexport)
 #else
-/* We are using this library */
+// We are using this library
 #define MLIR_RUNNERUTILS_EXPORT __declspec(dllimport)
 #endif // mlir_runner_utils_EXPORTS
 #endif // MLIR_RUNNERUTILS_EXPORT
 #else
 #define MLIR_RUNNERUTILS_EXPORT
 #endif // _WIN32
 
 #include <assert.h>

mlir/lib/CAPI/IR/AffineExpr.cpp

int mlirAffineExprIsMultipleOf(MlirAffineExpr affineExpr, int64_t factor) {
   return unwrap(affineExpr).isMultipleOf(factor);
 }
 
 int mlirAffineExprIsFunctionOfDim(MlirAffineExpr affineExpr,
                                   intptr_t position) {
   return unwrap(affineExpr).isFunctionOfDim(position);
 }
 
-/*============================================================================*/
-/* Affine Dimension Expression.                                               */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine Dimension Expression.
+//===----------------------------------------------------------------------===//
 
 MlirAffineExpr mlirAffineDimExprGet(MlirContext ctx, intptr_t position) {
   return wrap(getAffineDimExpr(position, unwrap(ctx)));
 }
 
 intptr_t mlirAffineDimExprGetPosition(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).cast<AffineDimExpr>().getPosition();
 }
 
-/*============================================================================*/
-/* Affine Symbol Expression.                                                  */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine Symbol Expression.
+//===----------------------------------------------------------------------===//
 
 MlirAffineExpr mlirAffineSymbolExprGet(MlirContext ctx, intptr_t position) {
   return wrap(getAffineSymbolExpr(position, unwrap(ctx)));
 }
 
 intptr_t mlirAffineSymbolExprGetPosition(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).cast<AffineSymbolExpr>().getPosition();
 }
 
-/*============================================================================*/
-/* Affine Constant Expression.                                                */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine Constant Expression.
+//===----------------------------------------------------------------------===//
 
 MlirAffineExpr mlirAffineConstantExprGet(MlirContext ctx, int64_t constant) {
   return wrap(getAffineConstantExpr(constant, unwrap(ctx)));
 }
 
 int64_t mlirAffineConstantExprGetValue(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).cast<AffineConstantExpr>().getValue();
 }
 
-/*============================================================================*/
-/* Affine Add Expression.                                                     */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine Add Expression.
+//===----------------------------------------------------------------------===//
 
 int mlirAffineExprIsAAdd(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).getKind() == mlir::AffineExprKind::Add;
 }
 
 MlirAffineExpr mlirAffineAddExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs) {
   return wrap(getAffineBinaryOpExpr(mlir::AffineExprKind::Add, unwrap(lhs),
                                     unwrap(rhs)));
 }
 
-/*============================================================================*/
-/* Affine Mul Expression.                                                     */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine Mul Expression.
+//===----------------------------------------------------------------------===//
 
 int mlirAffineExprIsAMul(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).getKind() == mlir::AffineExprKind::Mul;
 }
 
 MlirAffineExpr mlirAffineMulExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs) {
   return wrap(getAffineBinaryOpExpr(mlir::AffineExprKind::Mul, unwrap(lhs),
                                     unwrap(rhs)));
 }
 
-/*============================================================================*/
-/* Affine Mod Expression.                                                     */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine Mod Expression.
+//===----------------------------------------------------------------------===//
 
 int mlirAffineExprIsAMod(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).getKind() == mlir::AffineExprKind::Mod;
 }
 
 MlirAffineExpr mlirAffineModExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs) {
   return wrap(getAffineBinaryOpExpr(mlir::AffineExprKind::Mod, unwrap(lhs),
                                     unwrap(rhs)));
 }
 
-/*============================================================================*/
-/* Affine FloorDiv Expression.                                                */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine FloorDiv Expression.
+//===----------------------------------------------------------------------===//
 
 int mlirAffineExprIsAFloorDiv(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).getKind() == mlir::AffineExprKind::FloorDiv;
 }
 
 MlirAffineExpr mlirAffineFloorDivExprGet(MlirAffineExpr lhs,
                                          MlirAffineExpr rhs) {
   return wrap(getAffineBinaryOpExpr(mlir::AffineExprKind::FloorDiv, unwrap(lhs),
                                     unwrap(rhs)));
 }
 
-/*============================================================================*/
-/* Affine CeilDiv Expression.                                                */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine CeilDiv Expression.
+//===----------------------------------------------------------------------===//
 
 int mlirAffineExprIsACeilDiv(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).getKind() == mlir::AffineExprKind::CeilDiv;
 }
 
 MlirAffineExpr mlirAffineCeilDivExprGet(MlirAffineExpr lhs,
                                         MlirAffineExpr rhs) {
   return wrap(getAffineBinaryOpExpr(mlir::AffineExprKind::CeilDiv, unwrap(lhs),
                                     unwrap(rhs)));
 }
 
-/*============================================================================*/
-/* Affine Binary Operation Expression.                                        */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine Binary Operation Expression.
+//===----------------------------------------------------------------------===//
 
 MlirAffineExpr mlirAffineBinaryOpExprGetLHS(MlirAffineExpr affineExpr) {
   return wrap(unwrap(affineExpr).cast<AffineBinaryOpExpr>().getLHS());
 }
 
 MlirAffineExpr mlirAffineBinaryOpExprGetRHS(MlirAffineExpr affineExpr) {
   return wrap(unwrap(affineExpr).cast<AffineBinaryOpExpr>().getRHS());
 }

mlir/lib/CAPI/IR/IR.cpp

 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Parser.h"
 
 using namespace mlir;
 
-/* ========================================================================== */
-/* Context API.                                                               */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Context API.
+//===----------------------------------------------------------------------===//
 
 MlirContext mlirContextCreate() {
   auto *context = new MLIRContext;
   return wrap(context);
 }
 
 int mlirContextEqual(MlirContext ctx1, MlirContext ctx2) {
   return unwrap(ctx1) == unwrap(ctx2);
intptr_t mlirContextGetNumLoadedDialects(MlirContext context) {
   return static_cast<intptr_t>(unwrap(context)->getLoadedDialects().size());
 }
 
 MlirDialect mlirContextGetOrLoadDialect(MlirContext context,
                                         MlirStringRef name) {
   return wrap(unwrap(context)->getOrLoadDialect(unwrap(name)));
 }
 
-/* ========================================================================== */
-/* Dialect API.                                                               */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Dialect API.
+//===----------------------------------------------------------------------===//
 
 MlirContext mlirDialectGetContext(MlirDialect dialect) {
   return wrap(unwrap(dialect)->getContext());
 }
 
 int mlirDialectEqual(MlirDialect dialect1, MlirDialect dialect2) {
   return unwrap(dialect1) == unwrap(dialect2);
 }
 
 MlirStringRef mlirDialectGetNamespace(MlirDialect dialect) {
   return wrap(unwrap(dialect)->getNamespace());
 }
 
-/* ========================================================================== */
-/* Printing flags API.                                                        */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Printing flags API.
+//===----------------------------------------------------------------------===//
 
 MlirOpPrintingFlags mlirOpPrintingFlagsCreate() {
   return wrap(new OpPrintingFlags());
 }
 
 void mlirOpPrintingFlagsDestroy(MlirOpPrintingFlags flags) {
   delete unwrap(flags);
 }

 void mlirOpPrintingFlagsPrintGenericOpForm(MlirOpPrintingFlags flags) {
   unwrap(flags)->printGenericOpForm();
 }
 
 void mlirOpPrintingFlagsUseLocalScope(MlirOpPrintingFlags flags) {
   unwrap(flags)->useLocalScope();
 }
 
-/* ========================================================================== */
-/* Location API.                                                              */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Location API.
+//===----------------------------------------------------------------------===//
 
 MlirLocation mlirLocationFileLineColGet(MlirContext context,
                                         const char *filename, unsigned line,
                                         unsigned col) {
   return wrap(FileLineColLoc::get(filename, line, col, unwrap(context)));
 }
 
 MlirLocation mlirLocationUnknownGet(MlirContext context) {
   return wrap(UnknownLoc::get(unwrap(context)));
 }
 
 MlirContext mlirLocationGetContext(MlirLocation location) {
   return wrap(unwrap(location).getContext());
 }
 
 void mlirLocationPrint(MlirLocation location, MlirStringCallback callback,
                        void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(location).print(stream);
 }
 
-/* ========================================================================== */
-/* Module API.                                                                */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Module API.
+//===----------------------------------------------------------------------===//
 
 MlirModule mlirModuleCreateEmpty(MlirLocation location) {
   return wrap(ModuleOp::create(unwrap(location)));
 }
 
 MlirModule mlirModuleCreateParse(MlirContext context, const char *module) {
   OwningModuleRef owning = parseSourceString(module, unwrap(context));
   if (!owning)
void mlirModuleDestroy(MlirModule module) {
   // Transfer ownership to an OwningModuleRef so that its destructor is called.
   OwningModuleRef(unwrap(module));
 }
 
 MlirOperation mlirModuleGetOperation(MlirModule module) {
   return wrap(unwrap(module).getOperation());
 }
 
-/* ========================================================================== */
-/* Operation state API.                                                       */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Operation state API.
+//===----------------------------------------------------------------------===//
 
 MlirOperationState mlirOperationStateGet(const char *name, MlirLocation loc) {
   MlirOperationState state;
   state.name = name;
   state.location = loc;
   state.nResults = 0;
   state.results = nullptr;
   state.nOperands = 0;
void mlirOperationStateAddSuccessors(MlirOperationState *state, intptr_t n,
                                      MlirBlock *successors) {
   APPEND_ELEMS(MlirBlock, nSuccessors, successors);
 }
 void mlirOperationStateAddAttributes(MlirOperationState *state, intptr_t n,
                                      MlirNamedAttribute *attributes) {
   APPEND_ELEMS(MlirNamedAttribute, nAttributes, attributes);
 }
 
-/* ========================================================================== */
-/* Operation API.                                                             */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Operation API.
+//===----------------------------------------------------------------------===//
 
 MlirOperation mlirOperationCreate(const MlirOperationState *state) {
   assert(state);
   OperationState cppState(unwrap(state->location), state->name);
   SmallVector<Type, 4> resultStorage;
   SmallVector<Value, 8> operandStorage;
   SmallVector<Block *, 2> successorStorage;
   cppState.addTypes(unwrapList(state->nResults, state->results, resultStorage));

 void mlirOperationPrintWithFlags(MlirOperation op, MlirOpPrintingFlags flags,
                                  MlirStringCallback callback, void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(op)->print(stream, *unwrap(flags));
 }
 
 void mlirOperationDump(MlirOperation op) { return unwrap(op)->dump(); }
 
-/* ========================================================================== */
-/* Region API.                                                                */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Region API.
+//===----------------------------------------------------------------------===//
 
 MlirRegion mlirRegionCreate() { return wrap(new Region); }
 
 MlirBlock mlirRegionGetFirstBlock(MlirRegion region) {
   Region *cppRegion = unwrap(region);
   if (cppRegion->empty())
     return wrap(static_cast<Block *>(nullptr));
   return wrap(&cppRegion->front());
void mlirRegionInsertOwnedBlockBefore(MlirRegion region, MlirBlock reference,
   unwrap(region)->getBlocks().insert(Region::iterator(unwrap(reference)),
                                      unwrap(block));
 }
 
 void mlirRegionDestroy(MlirRegion region) {
   delete static_cast<Region *>(region.ptr);
 }
 
-/* ========================================================================== */
-/* Block API.                                                                 */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Block API.
+//===----------------------------------------------------------------------===//
 
 MlirBlock mlirBlockCreate(intptr_t nArgs, MlirType *args) {
   Block *b = new Block;
   for (intptr_t i = 0; i < nArgs; ++i)
     b->addArgument(unwrap(args[i]));
   return wrap(b);
 }
 

 }
 
 void mlirBlockPrint(MlirBlock block, MlirStringCallback callback,
                     void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(block)->print(stream);
 }
 
-/* ========================================================================== */
-/* Value API.                                                                 */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Value API.
+//===----------------------------------------------------------------------===//
 
 int mlirValueIsABlockArgument(MlirValue value) {
   return unwrap(value).isa<BlockArgument>();
 }
 
 int mlirValueIsAOpResult(MlirValue value) {
   return unwrap(value).isa<OpResult>();
 }

 void mlirValueDump(MlirValue value) { unwrap(value).dump(); }
 
 void mlirValuePrint(MlirValue value, MlirStringCallback callback,
                     void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(value).print(stream);
 }
 
-/* ========================================================================== */
-/* Type API.                                                                  */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Type API.
+//===----------------------------------------------------------------------===//
 
 MlirType mlirTypeParseGet(MlirContext context, const char *type) {
   return wrap(mlir::parseType(type, unwrap(context)));
 }
 
 MlirContext mlirTypeGetContext(MlirType type) {
   return wrap(unwrap(type).getContext());
 }
 
 int mlirTypeEqual(MlirType t1, MlirType t2) { return unwrap(t1) == unwrap(t2); }
 
 void mlirTypePrint(MlirType type, MlirStringCallback callback, void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(type).print(stream);
 }
 
 void mlirTypeDump(MlirType type) { unwrap(type).dump(); }
 
-/* ========================================================================== */
-/* Attribute API.                                                             */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Attribute API.
+//===----------------------------------------------------------------------===//
 
 MlirAttribute mlirAttributeParseGet(MlirContext context, const char *attr) {
   return wrap(mlir::parseAttribute(attr, unwrap(context)));
 }
 
 MlirContext mlirAttributeGetContext(MlirAttribute attribute) {
   return wrap(unwrap(attribute).getContext());
 }

 }
 
 void mlirAttributeDump(MlirAttribute attr) { unwrap(attr).dump(); }
 
 MlirNamedAttribute mlirNamedAttributeGet(const char *name, MlirAttribute attr) {
   return MlirNamedAttribute{name, attr};
 }
 
-/*============================================================================*/
-/* Identifier API.                                                            */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Identifier API.
+//===----------------------------------------------------------------------===//
 
 MlirIdentifier mlirIdentifierGet(MlirContext context, MlirStringRef str) {
   return wrap(Identifier::get(unwrap(str), unwrap(context)));
 }
 
 int mlirIdentifierEqual(MlirIdentifier ident, MlirIdentifier other) {
   return unwrap(ident) == unwrap(other);
 }
 
 MlirStringRef mlirIdentifierStr(MlirIdentifier ident) {
   return wrap(unwrap(ident).strref());
 }

mlir/lib/CAPI/IR/Pass.cpp

 #include "mlir/CAPI/IR.h"
 #include "mlir/CAPI/Pass.h"
 #include "mlir/CAPI/Support.h"
 #include "mlir/CAPI/Utils.h"
 #include "mlir/Pass/PassManager.h"
 
 using namespace mlir;
 
-/* ========================================================================== */
-/* PassManager/OpPassManager APIs. */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// PassManager/OpPassManager APIs.
+//===----------------------------------------------------------------------===//
 
 MlirPassManager mlirPassManagerCreate(MlirContext ctx) {
   return wrap(new PassManager(unwrap(ctx)));
 }
 
 void mlirPassManagerDestroy(MlirPassManager passManager) {
   delete unwrap(passManager);
 }

mlir/lib/CAPI/IR/StandardAttributes.cpp

 #include "mlir/CAPI/AffineMap.h"
 #include "mlir/CAPI/IR.h"
 #include "mlir/CAPI/Support.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/StandardTypes.h"
 
 using namespace mlir;
 
-/*============================================================================*/
-/* Affine map attribute.                                                      */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Affine map attribute.
+//===----------------------------------------------------------------------===//
 
 int mlirAttributeIsAAffineMap(MlirAttribute attr) {
   return unwrap(attr).isa<AffineMapAttr>();
 }
 
 MlirAttribute mlirAffineMapAttrGet(MlirAffineMap map) {
   return wrap(AffineMapAttr::get(unwrap(map)));
 }
 
 MlirAffineMap mlirAffineMapAttrGetValue(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<AffineMapAttr>().getValue());
 }
 
-/*============================================================================*/
-/* Array attribute.                                                           */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Array attribute.
+//===----------------------------------------------------------------------===//
 
 int mlirAttributeIsAArray(MlirAttribute attr) {
   return unwrap(attr).isa<ArrayAttr>();
 }
 
 MlirAttribute mlirArrayAttrGet(MlirContext ctx, intptr_t numElements,
                                MlirAttribute *elements) {
   SmallVector<Attribute, 8> attrs;
   return wrap(ArrayAttr::get(
       unwrapList(static_cast<size_t>(numElements), elements, attrs),
       unwrap(ctx)));
 }
 
 intptr_t mlirArrayAttrGetNumElements(MlirAttribute attr) {
   return static_cast<intptr_t>(unwrap(attr).cast<ArrayAttr>().size());
 }
 
 MlirAttribute mlirArrayAttrGetElement(MlirAttribute attr, intptr_t pos) {
   return wrap(unwrap(attr).cast<ArrayAttr>().getValue()[pos]);
 }
 
-/*============================================================================*/
-/* Dictionary attribute.                                                      */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Dictionary attribute.
+//===----------------------------------------------------------------------===//
 
 int mlirAttributeIsADictionary(MlirAttribute attr) {
   return unwrap(attr).isa<DictionaryAttr>();
 }
 
 MlirAttribute mlirDictionaryAttrGet(MlirContext ctx, intptr_t numElements,
                                     MlirNamedAttribute *elements) {
   SmallVector<NamedAttribute, 8> attributes;
MlirNamedAttribute mlirDictionaryAttrGetElement(MlirAttribute attr,
   return {attribute.first.c_str(), wrap(attribute.second)};
 }
 
 MlirAttribute mlirDictionaryAttrGetElementByName(MlirAttribute attr,
                                                  const char *name) {
   return wrap(unwrap(attr).cast<DictionaryAttr>().get(name));
 }
 
-/*============================================================================*/
-/* Floating point attribute.                                                  */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Floating point attribute.
+//===----------------------------------------------------------------------===//
 
 int mlirAttributeIsAFloat(MlirAttribute attr) {
   return unwrap(attr).isa<FloatAttr>();
 }
 
 MlirAttribute mlirFloatAttrDoubleGet(MlirContext ctx, MlirType type,
                                      double value) {
   return wrap(FloatAttr::get(unwrap(type), value));
 }
 
 MlirAttribute mlirFloatAttrDoubleGetChecked(MlirType type, double value,
                                             MlirLocation loc) {
   return wrap(FloatAttr::getChecked(unwrap(type), value, unwrap(loc)));
 }
 
 double mlirFloatAttrGetValueDouble(MlirAttribute attr) {
   return unwrap(attr).cast<FloatAttr>().getValueAsDouble();
 }
 
-/*============================================================================*/
-/* Integer attribute.                                                         */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Integer attribute.
+//===----------------------------------------------------------------------===//
 
 int mlirAttributeIsAInteger(MlirAttribute attr) {
   return unwrap(attr).isa<IntegerAttr>();
 }
 
 MlirAttribute mlirIntegerAttrGet(MlirType type, int64_t value) {
   return wrap(IntegerAttr::get(unwrap(type), value));
 }
 
 int64_t mlirIntegerAttrGetValueInt(MlirAttribute attr) {
   return unwrap(attr).cast<IntegerAttr>().getInt();
 }
 
-/*============================================================================*/
-/* Bool attribute.                                                            */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Bool attribute.
+//===----------------------------------------------------------------------===//
 
 int mlirAttributeIsABool(MlirAttribute attr) {
   return unwrap(attr).isa<BoolAttr>();
 }
 
 MlirAttribute mlirBoolAttrGet(MlirContext ctx, int value) {
   return wrap(BoolAttr::get(value, unwrap(ctx)));
 }
 
 int mlirBoolAttrGetValue(MlirAttribute attr) {
   return unwrap(attr).cast<BoolAttr>().getValue();
 }
 
-/*============================================================================*/
-/* Integer set attribute.                                                     */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Integer set attribute.
+//===----------------------------------------------------------------------===//
 
 int mlirAttributeIsAIntegerSet(MlirAttribute attr) {
   return unwrap(attr).isa<IntegerSetAttr>();
 }
 
-/*============================================================================*/
-/* Opaque attribute.                                                          */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Opaque attribute.
+//===----------------------------------------------------------------------===//
 
 int mlirAttributeIsAOpaque(MlirAttribute attr) {
   return unwrap(attr).isa<OpaqueAttr>();
 }
 
 MlirAttribute mlirOpaqueAttrGet(MlirContext ctx, const char *dialectNamespace,
                                 intptr_t dataLength, const char *data,
                                 MlirType type) {
   return wrap(OpaqueAttr::get(Identifier::get(dialectNamespace, unwrap(ctx)),
                               StringRef(data, dataLength), unwrap(type),
                               unwrap(ctx)));
 }
 
 const char *mlirOpaqueAttrGetDialectNamespace(MlirAttribute attr) {
   return unwrap(attr).cast<OpaqueAttr>().getDialectNamespace().c_str();
 }
 
 MlirStringRef mlirOpaqueAttrGetData(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<OpaqueAttr>().getAttrData());
 }
 
-/*============================================================================*/
-/* String attribute.                                                          */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// String attribute.
+//===----------------------------------------------------------------------===//
 
 int mlirAttributeIsAString(MlirAttribute attr) {
   return unwrap(attr).isa<StringAttr>();
 }
 
 MlirAttribute mlirStringAttrGet(MlirContext ctx, intptr_t length,
                                 const char *data) {
   return wrap(StringAttr::get(StringRef(data, length), unwrap(ctx)));
 }
 
 MlirAttribute mlirStringAttrTypedGet(MlirType type, intptr_t length,
                                      const char *data) {
   return wrap(StringAttr::get(StringRef(data, length), unwrap(type)));
 }
 
 MlirStringRef mlirStringAttrGetValue(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<StringAttr>().getValue());
 }
 
-/*============================================================================*/
-/* SymbolRef attribute.                                                       */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// SymbolRef attribute.
+//===----------------------------------------------------------------------===//
 
 int mlirAttributeIsASymbolRef(MlirAttribute attr) {
   return unwrap(attr).isa<SymbolRefAttr>();
 }
 
 MlirAttribute mlirSymbolRefAttrGet(MlirContext ctx, intptr_t length,
                                    const char *symbol, intptr_t numReferences,
                                    MlirAttribute *references) {
return static_cast<intptr_t>(
       unwrap(attr).cast<SymbolRefAttr>().getNestedReferences().size());
 }
 
 MlirAttribute mlirSymbolRefAttrGetNestedReference(MlirAttribute attr,
                                                   intptr_t pos) {
   return wrap(unwrap(attr).cast<SymbolRefAttr>().getNestedReferences()[pos]);
 }
 
-/*============================================================================*/
-/* Flat SymbolRef attribute.                                                  */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Flat SymbolRef attribute.
+//===----------------------------------------------------------------------===//
 
 int mlirAttributeIsAFlatSymbolRef(MlirAttribute attr) {
   return unwrap(attr).isa<FlatSymbolRefAttr>();
 }
 
 MlirAttribute mlirFlatSymbolRefAttrGet(MlirContext ctx, intptr_t length,
                                        const char *symbol) {
   return wrap(FlatSymbolRefAttr::get(StringRef(symbol, length), unwrap(ctx)));
 }
 
 MlirStringRef mlirFlatSymbolRefAttrGetValue(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<FlatSymbolRefAttr>().getValue());
 }
 
-/*============================================================================*/
-/* Type attribute.                                                            */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Type attribute.
+//===----------------------------------------------------------------------===//
 
 int mlirAttributeIsAType(MlirAttribute attr) {
   return unwrap(attr).isa<TypeAttr>();
 }
 
 MlirAttribute mlirTypeAttrGet(MlirType type) {
   return wrap(TypeAttr::get(unwrap(type)));
 }
 
 MlirType mlirTypeAttrGetValue(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<TypeAttr>().getValue());
 }
 
-/*============================================================================*/
-/* Unit attribute.                                                            */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Unit attribute.
+//===----------------------------------------------------------------------===//
 
 int mlirAttributeIsAUnit(MlirAttribute attr) {
   return unwrap(attr).isa<UnitAttr>();
 }
 
 MlirAttribute mlirUnitAttrGet(MlirContext ctx) {
   return wrap(UnitAttr::get(unwrap(ctx)));
 }
 
-/*============================================================================*/
-/* Elements attributes.                                                       */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Elements attributes.
+//===----------------------------------------------------------------------===//
 
 int mlirAttributeIsAElements(MlirAttribute attr) {
   return unwrap(attr).isa<ElementsAttr>();
 }
 
 MlirAttribute mlirElementsAttrGetValue(MlirAttribute attr, intptr_t rank,
                                        uint64_t *idxs) {
   return wrap(unwrap(attr).cast<ElementsAttr>().getValue(
       llvm::makeArrayRef(idxs, rank)));
 }
 
 int mlirElementsAttrIsValidIndex(MlirAttribute attr, intptr_t rank,
                                  uint64_t *idxs) {
   return unwrap(attr).cast<ElementsAttr>().isValidIndex(
       llvm::makeArrayRef(idxs, rank));
 }
 
 int64_t mlirElementsAttrGetNumElements(MlirAttribute attr) {
   return unwrap(attr).cast<ElementsAttr>().getNumElements();
 }
 
-/*============================================================================*/
-/* Dense elements attribute.                                                  */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Dense elements attribute.
+//===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // IsA support.
 
 int mlirAttributeIsADenseElements(MlirAttribute attr) {
   return unwrap(attr).isa<DenseElementsAttr>();
 }
 int mlirAttributeIsADenseIntElements(MlirAttribute attr) {

 }
 MlirStringRef mlirDenseElementsAttrGetStringValue(MlirAttribute attr,
                                                   intptr_t pos) {
   return wrap(
       *(unwrap(attr).cast<DenseElementsAttr>().getValues<StringRef>().begin() +
         pos));
 }
 
-/*============================================================================*/
-/* Opaque elements attribute.                                                 */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Opaque elements attribute.
+//===----------------------------------------------------------------------===//
 
 int mlirAttributeIsAOpaqueElements(MlirAttribute attr) {
   return unwrap(attr).isa<OpaqueElementsAttr>();
 }
 
-/*============================================================================*/
-/* Sparse elements attribute.                                                 */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Sparse elements attribute.
+//===----------------------------------------------------------------------===//
 
 int mlirAttributeIsASparseElements(MlirAttribute attr) {
   return unwrap(attr).isa<SparseElementsAttr>();
 }
 
 MlirAttribute mlirSparseElementsAttribute(MlirType shapedType,
                                           MlirAttribute denseIndices,
                                           MlirAttribute denseValues) {

mlir/lib/CAPI/IR/StandardTypes.cpp

 #include "mlir/CAPI/AffineMap.h"
 #include "mlir/CAPI/IR.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/Types.h"
 
 using namespace mlir;
 
-/* ========================================================================== */
-/* Integer types.                                                             */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Integer types.
+//===----------------------------------------------------------------------===//
 
 int mlirTypeIsAInteger(MlirType type) {
   return unwrap(type).isa<IntegerType>();
 }
 
 MlirType mlirIntegerTypeGet(MlirContext ctx, unsigned bitwidth) {
   return wrap(IntegerType::get(bitwidth, unwrap(ctx)));
 }

 int mlirIntegerTypeIsSigned(MlirType type) {
   return unwrap(type).cast<IntegerType>().isSigned();
 }
 
 int mlirIntegerTypeIsUnsigned(MlirType type) {
   return unwrap(type).cast<IntegerType>().isUnsigned();
 }
 
-/* ========================================================================== */
-/* Index type.                                                                */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Index type.
+//===----------------------------------------------------------------------===//
 
 int mlirTypeIsAIndex(MlirType type) { return unwrap(type).isa<IndexType>(); }
 
 MlirType mlirIndexTypeGet(MlirContext ctx) {
   return wrap(IndexType::get(unwrap(ctx)));
 }
 
-/* ========================================================================== */
-/* Floating-point types.                                                      */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Floating-point types.
+//===----------------------------------------------------------------------===//
 
 int mlirTypeIsABF16(MlirType type) { return unwrap(type).isBF16(); }
 
 MlirType mlirBF16TypeGet(MlirContext ctx) {
   return wrap(FloatType::getBF16(unwrap(ctx)));
 }
 
 int mlirTypeIsAF16(MlirType type) { return unwrap(type).isF16(); }

 }
 
 int mlirTypeIsAF64(MlirType type) { return unwrap(type).isF64(); }
 
 MlirType mlirF64TypeGet(MlirContext ctx) {
   return wrap(FloatType::getF64(unwrap(ctx)));
 }
 
-/* ========================================================================== */
-/* None type.                                                                 */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// None type.
+//===----------------------------------------------------------------------===//
 
 int mlirTypeIsANone(MlirType type) { return unwrap(type).isa<NoneType>(); }
 
 MlirType mlirNoneTypeGet(MlirContext ctx) {
   return wrap(NoneType::get(unwrap(ctx)));
 }
 
-/* ========================================================================== */
-/* Complex type.                                                              */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Complex type.
+//===----------------------------------------------------------------------===//
 
 int mlirTypeIsAComplex(MlirType type) {
   return unwrap(type).isa<ComplexType>();
 }
 
 MlirType mlirComplexTypeGet(MlirType elementType) {
   return wrap(ComplexType::get(unwrap(elementType)));
 }
 
 MlirType mlirComplexTypeGetElementType(MlirType type) {
   return wrap(unwrap(type).cast<ComplexType>().getElementType());
 }
 
-/* ========================================================================== */
-/* Shaped type.                                                               */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Shaped type.
+//===----------------------------------------------------------------------===//
 
 int mlirTypeIsAShaped(MlirType type) { return unwrap(type).isa<ShapedType>(); }
 
 MlirType mlirShapedTypeGetElementType(MlirType type) {
   return wrap(unwrap(type).cast<ShapedType>().getElementType());
 }
 
 int mlirShapedTypeHasRank(MlirType type) {

 int mlirShapedTypeIsDynamicSize(int64_t size) {
   return ShapedType::isDynamic(size);
 }
 
 int mlirShapedTypeIsDynamicStrideOrOffset(int64_t val) {
   return ShapedType::isDynamicStrideOrOffset(val);
 }
 
-/* ========================================================================== */
-/* Vector type.                                                               */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Vector type.
+//===----------------------------------------------------------------------===//
 
 int mlirTypeIsAVector(MlirType type) { return unwrap(type).isa<VectorType>(); }
 
 MlirType mlirVectorTypeGet(intptr_t rank, int64_t *shape,
                            MlirType elementType) {
   return wrap(
       VectorType::get(llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
                       unwrap(elementType)));
 }
 
 MlirType mlirVectorTypeGetChecked(intptr_t rank, int64_t *shape,
                                   MlirType elementType, MlirLocation loc) {
   return wrap(VectorType::getChecked(
       llvm::makeArrayRef(shape, static_cast<size_t>(rank)), unwrap(elementType),
       unwrap(loc)));
 }
 
-/* ========================================================================== */
-/* Ranked / Unranked tensor type.                                             */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Ranked / Unranked tensor type.
+//===----------------------------------------------------------------------===//
 
 int mlirTypeIsATensor(MlirType type) { return unwrap(type).isa<TensorType>(); }
 
 int mlirTypeIsARankedTensor(MlirType type) {
   return unwrap(type).isa<RankedTensorType>();
 }
 
 int mlirTypeIsAUnrankedTensor(MlirType type) {
MlirType mlirUnrankedTensorTypeGet(MlirType elementType) {
   return wrap(UnrankedTensorType::get(unwrap(elementType)));
 }
 
 MlirType mlirUnrankedTensorTypeGetChecked(MlirType elementType,
                                           MlirLocation loc) {
   return wrap(UnrankedTensorType::getChecked(unwrap(elementType), unwrap(loc)));
 }
 
-/* ========================================================================== */
-/* Ranked / Unranked MemRef type.                                             */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Ranked / Unranked MemRef type.
+//===----------------------------------------------------------------------===//
 
 int mlirTypeIsAMemRef(MlirType type) { return unwrap(type).isa<MemRefType>(); }
 
 MlirType mlirMemRefTypeGet(MlirType elementType, intptr_t rank, int64_t *shape,
                            intptr_t numMaps, MlirAffineMap *affineMaps,
                            unsigned memorySpace) {
   SmallVector<AffineMap, 1> maps;
   (void)unwrapList(numMaps, affineMaps, maps);
MlirType mlirUnrankedMemRefTypeGetChecked(MlirType elementType,
   return wrap(UnrankedMemRefType::getChecked(unwrap(elementType), memorySpace,
                                              unwrap(loc)));
 }
 
 unsigned mlirUnrankedMemrefGetMemorySpace(MlirType type) {
   return unwrap(type).cast<UnrankedMemRefType>().getMemorySpace();
 }
 
-/* ========================================================================== */
-/* Tuple type.                                                                */
-/* ========================================================================== */
+//===----------------------------------------------------------------------===//
+// Tuple type.
+//===----------------------------------------------------------------------===//
 
 int mlirTypeIsATuple(MlirType type) { return unwrap(type).isa<TupleType>(); }
 
 MlirType mlirTupleTypeGet(MlirContext ctx, intptr_t numElements,
                           MlirType *elements) {
   SmallVector<Type, 4> types;
   ArrayRef<Type> typeRef = unwrapList(numElements, elements, types);
   return wrap(TupleType::get(typeRef, unwrap(ctx)));
 }
 
 intptr_t mlirTupleTypeGetNumTypes(MlirType type) {
   return unwrap(type).cast<TupleType>().size();
 }
 
 MlirType mlirTupleTypeGetType(MlirType type, intptr_t pos) {
   return wrap(unwrap(type).cast<TupleType>().getType(static_cast<size_t>(pos)));
 }
 
-/*============================================================================*/
-/* Function type.                                                             */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// Function type.
+//===----------------------------------------------------------------------===//
 
 int mlirTypeIsAFunction(MlirType type) {
   return unwrap(type).isa<FunctionType>();
 }
 
 MlirType mlirFunctionTypeGet(MlirContext ctx, intptr_t numInputs,
                              MlirType *inputs, intptr_t numResults,
                              MlirType *results) {

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

 
 ConvertToLLVMPattern::ConvertToLLVMPattern(StringRef rootOpName,
                                            MLIRContext *context,
                                            LLVMTypeConverter &typeConverter,
                                            PatternBenefit benefit)
     : ConversionPattern(rootOpName, benefit, typeConverter, context),
       typeConverter(typeConverter) {}
 
-/*============================================================================*/
-/* StructBuilder implementation                                               */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// StructBuilder implementation
+//===----------------------------------------------------------------------===//
 
 StructBuilder::StructBuilder(Value v) : value(v) {
   assert(value != nullptr && "value cannot be null");
   structType = value.getType().dyn_cast<LLVM::LLVMType>();
   assert(structType && "expected llvm type");
 }
 
 Value StructBuilder::extractPtr(OpBuilder &builder, Location loc,
                                 unsigned pos) {
   Type type = structType.cast<LLVM::LLVMType>().getStructElementType(pos);
   return builder.create<LLVM::ExtractValueOp>(loc, type, value,
                                               builder.getI64ArrayAttr(pos));
 }
 
 void StructBuilder::setPtr(OpBuilder &builder, Location loc, unsigned pos,
                            Value ptr) {
   value = builder.create<LLVM::InsertValueOp>(loc, structType, value, ptr,
                                               builder.getI64ArrayAttr(pos));
 }
 
-/*============================================================================*/
-/* ComplexStructBuilder implementation                                        */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// ComplexStructBuilder implementation
+//===----------------------------------------------------------------------===//
 
 ComplexStructBuilder ComplexStructBuilder::undef(OpBuilder &builder,
                                                  Location loc, Type type) {
   Value val = builder.create<LLVM::UndefOp>(loc, type.cast<LLVM::LLVMType>());
   return ComplexStructBuilder(val);
 }
 
 void ComplexStructBuilder::setReal(OpBuilder &builder, Location loc,
void ComplexStructBuilder::setImaginary(OpBuilder &builder, Location loc,
                                         Value imaginary) {
   setPtr(builder, loc, kImaginaryPosInComplexNumberStruct, imaginary);
 }
 
 Value ComplexStructBuilder::imaginary(OpBuilder &builder, Location loc) {
   return extractPtr(builder, loc, kImaginaryPosInComplexNumberStruct);
 }
 
-/*============================================================================*/
-/* MemRefDescriptor implementation                                            */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// MemRefDescriptor implementation
+//===----------------------------------------------------------------------===//
 
 /// Construct a helper for the given descriptor value.
 MemRefDescriptor::MemRefDescriptor(Value descriptor)
     : StructBuilder(descriptor) {
   assert(value != nullptr && "value cannot be null");
   indexType = value.getType().cast<LLVM::LLVMType>().getStructElementType(
       kOffsetPosInMemRefDescriptor);
 }

 
 /// Returns the number of non-aggregate values that would be produced by
 /// `unpack`.
 unsigned MemRefDescriptor::getNumUnpackedValues(MemRefType type) {
   // Two pointers, offset, <rank> sizes, <rank> shapes.
   return 3 + 2 * type.getRank();
 }
 
-/*============================================================================*/
-/* MemRefDescriptorView implementation.                                       */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// MemRefDescriptorView implementation.
+//===----------------------------------------------------------------------===//
 
 MemRefDescriptorView::MemRefDescriptorView(ValueRange range)
     : rank((range.size() - kSizePosInMemRefDescriptor) / 2), elements(range) {}
 
 Value MemRefDescriptorView::allocatedPtr() {
   return elements[kAllocatedPtrPosInMemRefDescriptor];
 }
 
 Value MemRefDescriptorView::alignedPtr() {
   return elements[kAlignedPtrPosInMemRefDescriptor];
 }
 
 Value MemRefDescriptorView::offset() {
   return elements[kOffsetPosInMemRefDescriptor];
 }
 
 Value MemRefDescriptorView::size(unsigned pos) {
   return elements[kSizePosInMemRefDescriptor + pos];
 }
 
 Value MemRefDescriptorView::stride(unsigned pos) {
   return elements[kSizePosInMemRefDescriptor + rank + pos];
 }
 
-/*============================================================================*/
-/* UnrankedMemRefDescriptor implementation                                    */
-/*============================================================================*/
+//===----------------------------------------------------------------------===//
+// UnrankedMemRefDescriptor implementation
+//===----------------------------------------------------------------------===//
 
 /// Construct a helper for the given descriptor value.
 UnrankedMemRefDescriptor::UnrankedMemRefDescriptor(Value descriptor)
     : StructBuilder(descriptor) {}
 
 /// Builds IR creating an `undef` value of the descriptor type.
 UnrankedMemRefDescriptor UnrankedMemRefDescriptor::undef(OpBuilder &builder,
                                                          Location loc,

mlir/test/CAPI/ir.c

-/*===- ir.c - Simple test of C APIs ---------------------------------------===*\
-|*                                                                            *|
-|* 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                    *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
+//===- ir.c - Simple test of C APIs ---------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
 
 /* RUN: mlir-capi-ir-test 2>&1 | FileCheck %s
  */
 
 #include "mlir-c/IR.h"
 #include "mlir-c/AffineExpr.h"
 #include "mlir-c/AffineMap.h"
 #include "mlir-c/Diagnostics.h"

mlir/test/CAPI/pass.c

-/*===- pass.c - Simple test of C APIs -------------------------------------===*\
-|*                                                                            *|
-|* 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                    *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
+//===- pass.c - Simple test of C APIs -------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
 
 /* RUN: mlir-capi-pass-test 2>&1 | FileCheck %s
  */
 
 #include "mlir-c/Pass.h"
 #include "mlir-c/IR.h"
 #include "mlir-c/Registration.h"
 #include "mlir-c/Transforms.h"

mlir/test/mlir-cpu-runner/include/mlir_test_cblas.h

 //===- mlir_test_cblas.h - Simple Blas subset -----------------------------===//
 //
 // 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_CPU_RUNNER_MLIR_TEST_CBLAS_H_
 #define MLIR_CPU_RUNNER_MLIR_TEST_CBLAS_H_
 
 #include "mlir/ExecutionEngine/RunnerUtils.h"
 
 #ifdef _WIN32
 #ifndef MLIR_TEST_CBLAS_EXPORT
 #ifdef mlir_test_cblas_EXPORTS
-/* We are building this library */
+// We are building this library
 #define MLIR_TEST_CBLAS_EXPORT __declspec(dllexport)
 #else
-/* We are using this library */
+// We are using this library
 #define MLIR_TEST_CBLAS_EXPORT __declspec(dllimport)
 #endif // mlir_test_cblas_EXPORTS
 #endif // MLIR_TEST_CBLAS_EXPORT
 #else
 #define MLIR_TEST_CBLAS_EXPORT
 #endif // _WIN32
 
 /// This reproduces a minimal subset of mlir_test_cblas to allow integration

mlir/test/mlir-cpu-runner/include/mlir_test_cblas_interface.h

 //===- mlir_test_cblas_interface.h - Simple Blas subset interface ---------===//
 //
 // 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_CPU_RUNNER_MLIR_TEST_CBLAS_INTERFACE_H_
 #define MLIR_CPU_RUNNER_MLIR_TEST_CBLAS_INTERFACE_H_
 
 #include "mlir/ExecutionEngine/RunnerUtils.h"
 
 #ifdef _WIN32
 #ifndef MLIR_TEST_CBLAS_INTERFACE_EXPORT
 #ifdef mlir_test_cblas_interface_EXPORTS
-/* We are building this library */
+// We are building this library
 #define MLIR_TEST_CBLAS_INTERFACE_EXPORT __declspec(dllexport)
 #else
-/* We are using this library */
+// We are using this library
 #define MLIR_TEST_CBLAS_INTERFACE_EXPORT __declspec(dllimport)
 #endif // mlir_test_cblas_interface_EXPORTS
 #endif // MLIR_TEST_CBLAS_INTERFACE_EXPORT
 #else
 #define MLIR_TEST_CBLAS_INTERFACE_EXPORT
 #endif // _WIN32
 
 extern "C" MLIR_TEST_CBLAS_INTERFACE_EXPORT void