[mlir] Fix -Wstrict-prototypes warnings

[tblah]

Summary

These warnings prevent compilation using clang with -DLLVM_ENABLE_WERROR=On

[nicolasvasilache]

commit message seems hosed

[tblah]

In D139322#3970772, @nicolasvasilache wrote:

commit message seems hosed

Sorry, that should be fixed now

[aartbik]

LGTM for sparse change

[tblah]

ping @nicolasvasilache

mlir/include/mlir-c/BuiltinAttributes.h

 #include "mlir-c/IR.h"
 #include "mlir-c/Support.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /// Returns an empty attribute.
-MLIR_CAPI_EXPORTED MlirAttribute mlirAttributeGetNull();
+MLIR_CAPI_EXPORTED MlirAttribute mlirAttributeGetNull(void);
 
 //===----------------------------------------------------------------------===//
 // Affine map attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is an affine map attribute.
 MLIR_CAPI_EXPORTED bool mlirAttributeIsAAffineMap(MlirAttribute attr);
 

mlir/include/mlir-c/BuiltinTypes.h

MLIR_CAPI_EXPORTED int64_t mlirShapedTypeGetDimSize(MlirType type,
                                                     intptr_t dim);
 
 /// Checks whether the given value is used as a placeholder for dynamic sizes
 /// in shaped types.
 MLIR_CAPI_EXPORTED bool mlirShapedTypeIsDynamicSize(int64_t size);
 
 /// Returns the value indicating a dynamic size in a shaped type. Prefer
 /// mlirShapedTypeIsDynamicSize to direct comparisons with this value.
-MLIR_CAPI_EXPORTED int64_t mlirShapedTypeGetDynamicSize();
+MLIR_CAPI_EXPORTED int64_t mlirShapedTypeGetDynamicSize(void);
 
 /// Checks whether the given value is used as a placeholder for dynamic strides
 /// and offsets in shaped types.
 MLIR_CAPI_EXPORTED bool mlirShapedTypeIsDynamicStrideOrOffset(int64_t val);
 
 /// Returns the value indicating a dynamic stride or offset in a shaped type.
 /// Prefer mlirShapedTypeGetDynamicStrideOrOffset to direct comparisons with
 /// this value.
-MLIR_CAPI_EXPORTED int64_t mlirShapedTypeGetDynamicStrideOrOffset();
+MLIR_CAPI_EXPORTED int64_t mlirShapedTypeGetDynamicStrideOrOffset(void);
 
 //===----------------------------------------------------------------------===//
 // Vector type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a Vector type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsAVector(MlirType type);
 

mlir/include/mlir-c/Dialect/Quant.h

 //===---------------------------------------------------------------------===//
 // QuantizedType
 //===---------------------------------------------------------------------===//
 
 /// Returns `true` if the given type is a quantization dialect type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsAQuantizedType(MlirType type);
 
 /// Returns the bit flag used to indicate signedness of a quantized type.
-MLIR_CAPI_EXPORTED unsigned mlirQuantizedTypeGetSignedFlag();
+MLIR_CAPI_EXPORTED unsigned mlirQuantizedTypeGetSignedFlag(void);
 
 /// Returns the minimum possible value stored by a quantized type.
 MLIR_CAPI_EXPORTED int64_t mlirQuantizedTypeGetDefaultMinimumForInteger(
     bool isSigned, unsigned integralWidth);
 
 /// Returns the maximum possible value stored by a quantized type.
 MLIR_CAPI_EXPORTED int64_t mlirQuantizedTypeGetDefaultMaximumForInteger(
     bool isSigned, unsigned integralWidth);

mlir/include/mlir-c/IR.h

 };
 typedef struct MlirNamedAttribute MlirNamedAttribute;
 
 //===----------------------------------------------------------------------===//
 // Context API.
 //===----------------------------------------------------------------------===//
 
 /// Creates an MLIR context and transfers its ownership to the caller.
-MLIR_CAPI_EXPORTED MlirContext mlirContextCreate();
+MLIR_CAPI_EXPORTED MlirContext mlirContextCreate(void);
 
 /// Checks if two contexts are equal.
 MLIR_CAPI_EXPORTED bool mlirContextEqual(MlirContext ctx1, MlirContext ctx2);
 
 /// Checks whether a context is null.
 static inline bool mlirContextIsNull(MlirContext context) {
   return !context.ptr;
 }

 //===----------------------------------------------------------------------===//
 
 struct MlirDialectHandle {
   const void *ptr;
 };
 typedef struct MlirDialectHandle MlirDialectHandle;
 
 #define MLIR_DECLARE_CAPI_DIALECT_REGISTRATION(Name, Namespace)                \
-  MLIR_CAPI_EXPORTED MlirDialectHandle mlirGetDialectHandle__##Namespace##__()
+  MLIR_CAPI_EXPORTED MlirDialectHandle mlirGetDialectHandle__##Namespace##__(  \
+      void)
 
 /// Returns the namespace associated with the provided dialect handle.
 MLIR_CAPI_EXPORTED
 MlirStringRef mlirDialectHandleGetNamespace(MlirDialectHandle);
 
 /// Inserts the dialect associated with the provided dialect handle into the
 /// provided dialect registry
 MLIR_CAPI_EXPORTED void mlirDialectHandleInsertDialect(MlirDialectHandle,
                                                        MlirDialectRegistry);
 
 /// Registers the dialect associated with the provided dialect handle.
 MLIR_CAPI_EXPORTED void mlirDialectHandleRegisterDialect(MlirDialectHandle,
                                                          MlirContext);
 
 /// Loads the dialect associated with the provided dialect handle.
 MLIR_CAPI_EXPORTED MlirDialect mlirDialectHandleLoadDialect(MlirDialectHandle,
                                                             MlirContext);
 
 //===----------------------------------------------------------------------===//
 // DialectRegistry API.
 //===----------------------------------------------------------------------===//
 
 /// Creates a dialect registry and transfers its ownership to the caller.
-MLIR_CAPI_EXPORTED MlirDialectRegistry mlirDialectRegistryCreate();
+MLIR_CAPI_EXPORTED MlirDialectRegistry mlirDialectRegistryCreate(void);
 
 /// Checks if the dialect registry is null.
 static inline bool mlirDialectRegistryIsNull(MlirDialectRegistry registry) {
   return !registry.ptr;
 }
 
 /// Takes a dialect registry owned by the caller and destroys it.
 MLIR_CAPI_EXPORTED void

 // 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().
-MLIR_CAPI_EXPORTED MlirOpPrintingFlags mlirOpPrintingFlagsCreate();
+MLIR_CAPI_EXPORTED MlirOpPrintingFlags mlirOpPrintingFlagsCreate(void);
 
 /// Destroys printing flags created with mlirOpPrintingFlagsCreate.
 MLIR_CAPI_EXPORTED 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.

 /// ownership is transferred to the block of the other operation.
 MLIR_CAPI_EXPORTED void mlirOperationMoveBefore(MlirOperation op,
                                                 MlirOperation other);
 //===----------------------------------------------------------------------===//
 // Region API.
 //===----------------------------------------------------------------------===//
 
 /// Creates a new empty region and transfers ownership to the caller.
-MLIR_CAPI_EXPORTED MlirRegion mlirRegionCreate();
+MLIR_CAPI_EXPORTED MlirRegion mlirRegionCreate(void);
 
 /// Takes a region owned by the caller and destroys it.
 MLIR_CAPI_EXPORTED void mlirRegionDestroy(MlirRegion region);
 
 /// Checks whether a region is null.
 static inline bool mlirRegionIsNull(MlirRegion region) { return !region.ptr; }
 
 /// Checks whether two region handles point to the same region. This does not

 MLIR_CAPI_EXPORTED MlirStringRef mlirIdentifierStr(MlirIdentifier ident);
 
 //===----------------------------------------------------------------------===//
 // Symbol and SymbolTable API.
 //===----------------------------------------------------------------------===//
 
 /// Returns the name of the attribute used to store symbol names compatible with
 /// symbol tables.
-MLIR_CAPI_EXPORTED MlirStringRef mlirSymbolTableGetSymbolAttributeName();
+MLIR_CAPI_EXPORTED MlirStringRef mlirSymbolTableGetSymbolAttributeName(void);
 
 /// Returns the name of the attribute used to store symbol visibility.
-MLIR_CAPI_EXPORTED MlirStringRef mlirSymbolTableGetVisibilityAttributeName();
+MLIR_CAPI_EXPORTED MlirStringRef
+mlirSymbolTableGetVisibilityAttributeName(void);
 
 /// Creates a symbol table for the given operation. If the operation does not
 /// have the SymbolTable trait, returns a null symbol table.
 MLIR_CAPI_EXPORTED MlirSymbolTable
 mlirSymbolTableCreate(MlirOperation operation);
 
 /// Returns true if the symbol table is null.
 static inline bool mlirSymbolTableIsNull(MlirSymbolTable symbolTable) {

mlir/include/mlir-c/RegisterEverything.h

 
 /// Appends all upstream dialects and extensions to the dialect registry.
 MLIR_CAPI_EXPORTED void mlirRegisterAllDialects(MlirDialectRegistry registry);
 
 /// Register all translations to LLVM IR for dialects that can support it.
 MLIR_CAPI_EXPORTED void mlirRegisterAllLLVMTranslations(MlirContext context);
 
 /// Register all compiler passes of MLIR.
-MLIR_CAPI_EXPORTED void mlirRegisterAllPasses();
+MLIR_CAPI_EXPORTED void mlirRegisterAllPasses(void);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_REGISTER_EVERYTHING_H

mlir/include/mlir-c/Support.h

 }
 
 /// Checks if the given logical result represents a failure.
 inline static bool mlirLogicalResultIsFailure(MlirLogicalResult res) {
   return res.value == 0;
 }
 
 /// Creates a logical result representing a success.
-inline static MlirLogicalResult mlirLogicalResultSuccess() {
+inline static MlirLogicalResult mlirLogicalResultSuccess(void) {
   MlirLogicalResult res = {1};
   return res;
 }
 
 /// Creates a logical result representing a failure.
-inline static MlirLogicalResult mlirLogicalResultFailure() {
+inline static MlirLogicalResult mlirLogicalResultFailure(void) {
   MlirLogicalResult res = {0};
   return res;
 }
 
 //===----------------------------------------------------------------------===//
 // TypeID API.
 //===----------------------------------------------------------------------===//
 

 /// Returns the hash value of the type id.
 MLIR_CAPI_EXPORTED size_t mlirTypeIDHashValue(MlirTypeID typeID);
 
 //===----------------------------------------------------------------------===//
 // TypeIDAllocator API.
 //===----------------------------------------------------------------------===//
 
 /// Creates a type id allocator for dynamic type id creation
-MLIR_CAPI_EXPORTED MlirTypeIDAllocator mlirTypeIDAllocatorCreate();
+MLIR_CAPI_EXPORTED MlirTypeIDAllocator mlirTypeIDAllocatorCreate(void);
 
 /// Deallocates the allocator and all allocated type ids
 MLIR_CAPI_EXPORTED void
 mlirTypeIDAllocatorDestroy(MlirTypeIDAllocator allocator);
 
 /// Allocates a type id that is valid for the lifetime of the allocator
 MLIR_CAPI_EXPORTED MlirTypeID
 mlirTypeIDAllocatorAllocateTypeID(MlirTypeIDAllocator allocator);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_SUPPORT_H

mlir/test/CAPI/execution_engine.c

void lowerModuleToLLVM(MlirContext ctx, MlirModule module) {
   if (mlirLogicalResultIsFailure(status)) {
     fprintf(stderr, "Unexpected failure running pass pipeline\n");
     exit(2);
   }
   mlirPassManagerDestroy(pm);
 }
 
 // CHECK-LABEL: Running test 'testSimpleExecution'
-void testSimpleExecution() {
+void testSimpleExecution(void) {
   MlirContext ctx = mlirContextCreate();
   registerAllUpstreamDialects(ctx);
 
   MlirModule module = mlirModuleCreateParse(
       ctx, mlirStringRefCreateFromCString(
                // clang-format off
 "module {                                                                    \n"
 "  func.func @add(%arg0 : i32) -> i32 attributes { llvm.emit_c_interface } {     \n"
"}"));
   }
   // CHECK: Input: 42 Result: 84
   printf("Input: %d Result: %d\n", input, result);
   mlirExecutionEngineDestroy(jit);
   mlirModuleDestroy(module);
   mlirContextDestroy(ctx);
 }
 
-int main() {
+int main(void) {
 
 #define _STRINGIFY(x) #x
 #define STRINGIFY(x) _STRINGIFY(x)
 #define TEST(test)                                                             \
   printf("Running test '" STRINGIFY(test) "'\n");                              \
   test();
 
   TEST(testSimpleExecution);
   return 0;
 }

mlir/test/CAPI/ir.c

int printIntegerSet(MlirContext ctx) {
   if (!mlirAffineExprEqual(cstr1, isEq1 ? d0minusS0 : d1minus42))
     return 11;
   if (!mlirAffineExprEqual(cstr2, isEq2 ? d0minusS0 : d1minus42))
     return 12;
 
   return 0;
 }
 
-int registerOnlyStd() {
+int registerOnlyStd(void) {
   MlirContext ctx = mlirContextCreate();
   // The built-in dialect is always loaded.
   if (mlirContextGetNumLoadedDialects(ctx) != 1)
     return 1;
 
   MlirDialectHandle stdHandle = mlirGetDialectHandle__func__();
 
   MlirDialect std = mlirContextGetOrLoadDialect(
fprintf(stderr, "not_existing_dialect.not_existing_op is_registered: %d\n",
               ctx, mlirStringRefCreateFromCString(
                        "not_existing_dialect.not_existing_op")));
 
   mlirContextDestroy(ctx);
   return 0;
 }
 
 /// Tests backreference APIs
-static int testBackreferences() {
+static int testBackreferences(void) {
   fprintf(stderr, "@test_backreferences\n");
 
   MlirContext ctx = mlirContextCreate();
   mlirContextSetAllowUnregisteredDialects(ctx, true);
   MlirLocation loc = mlirLocationUnknownGet(ctx);
 
   MlirOperationState opState =
       mlirOperationStateGet(mlirStringRefCreateFromCString("invalid.op"), loc);
static int testBackreferences(void) {
   mlirOperationDestroy(op);
   mlirContextDestroy(ctx);
 
   // CHECK-LABEL: @test_backreferences
   return 0;
 }
 
 /// Tests operand APIs.
-int testOperands() {
+int testOperands(void) {
   fprintf(stderr, "@testOperands\n");
   // CHECK-LABEL: @testOperands
 
   MlirContext ctx = mlirContextCreate();
   registerAllUpstreamDialects(ctx);
 
   mlirContextGetOrLoadDialect(ctx, mlirStringRefCreateFromCString("arith"));
   mlirContextGetOrLoadDialect(ctx, mlirStringRefCreateFromCString("test"));
int testOperands(void) {
   mlirOperationDestroy(constZero);
   mlirOperationDestroy(constOne);
   mlirContextDestroy(ctx);
 
   return 0;
 }
 
 /// Tests clone APIs.
-int testClone() {
+int testClone(void) {
   fprintf(stderr, "@testClone\n");
   // CHECK-LABEL: @testClone
 
   MlirContext ctx = mlirContextCreate();
   registerAllUpstreamDialects(ctx);
 
   mlirContextGetOrLoadDialect(ctx, mlirStringRefCreateFromCString("func"));
   MlirLocation loc = mlirLocationUnknownGet(ctx);
int testSymbolTable(MlirContext ctx) {
 
   mlirSymbolTableDestroy(symbolTable);
   mlirModuleDestroy(module);
   mlirModuleDestroy(otherModule);
 
   return 0;
 }
 
-int testDialectRegistry() {
+int testDialectRegistry(void) {
   fprintf(stderr, "@testDialectRegistry\n");
 
   MlirDialectRegistry registry = mlirDialectRegistryCreate();
   if (mlirDialectRegistryIsNull(registry)) {
     fprintf(stderr, "ERROR: Expected registry to be present\n");
     return 1;
   }
 
int testDialectRegistry(void) {
   }
 
   mlirContextDestroy(ctx);
   mlirDialectRegistryDestroy(registry);
 
   return 0;
 }
 
-void testDiagnostics() {
+void testDiagnostics(void) {
   MlirContext ctx = mlirContextCreate();
   MlirDiagnosticHandlerID id = mlirContextAttachDiagnosticHandler(
       ctx, errorHandler, (void *)42, deleteUserData);
   fprintf(stderr, "@test_diagnostics\n");
   MlirLocation unknownLoc = mlirLocationUnknownGet(ctx);
   mlirEmitError(unknownLoc, "test diagnostics");
   MlirLocation fileLineColLoc = mlirLocationFileLineColGet(
       ctx, mlirStringRefCreateFromCString("file.c"), 1, 2);
void testDiagnostics(void) {
   // CHECK:   test diagnostics
   // CHECK:   loc(fused["named", callsite("other-file.c":2:3 at "file.c":1:2)])
   // CHECK: deleting user data (userData: 42)
   // CHECK-NOT: processing diagnostic
   // CHECK:     more test diagnostics
   mlirContextDestroy(ctx);
 }
 
-int main() {
+int main(void) {
   MlirContext ctx = mlirContextCreate();
   registerAllUpstreamDialects(ctx);
   mlirContextGetOrLoadDialect(ctx, mlirStringRefCreateFromCString("func"));
   mlirContextGetOrLoadDialect(ctx, mlirStringRefCreateFromCString("memref"));
   mlirContextGetOrLoadDialect(ctx, mlirStringRefCreateFromCString("shape"));
   mlirContextGetOrLoadDialect(ctx, mlirStringRefCreateFromCString("scf"));
 
   if (constructAndTraverseIr(ctx))

mlir/test/CAPI/llvm.c

static void testTypeCreation(MlirContext ctx) {
   MlirType i32_i64_s = mlirLLVMStructTypeLiteralGet(ctx, 2, i32_i64_arr, false);
   MlirType i32_i64_s_ref =
       mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(i32_i64_s_text));
   // CHECK: !llvm.struct<(i32, i64)>: 1
   fprintf(stderr, "%s: %d\n", i32_i64_s_text,
           mlirTypeEqual(i32_i64_s, i32_i64_s_ref));
 }
 
-int main() {
+int main(void) {
   MlirContext ctx = mlirContextCreate();
   mlirDialectHandleRegisterDialect(mlirGetDialectHandle__llvm__(), ctx);
   mlirContextGetOrLoadDialect(ctx, mlirStringRefCreateFromCString("llvm"));
   testTypeCreation(ctx);
   mlirContextDestroy(ctx);
   return 0;
 }

mlir/test/CAPI/pass.c

 
 static void registerAllUpstreamDialects(MlirContext ctx) {
   MlirDialectRegistry registry = mlirDialectRegistryCreate();
   mlirRegisterAllDialects(registry);
   mlirContextAppendDialectRegistry(ctx, registry);
   mlirDialectRegistryDestroy(registry);
 }
 
-void testRunPassOnModule() {
+void testRunPassOnModule(void) {
   MlirContext ctx = mlirContextCreate();
   registerAllUpstreamDialects(ctx);
 
   MlirModule module = mlirModuleCreateParse(
       ctx,
       // clang-format off
                             mlirStringRefCreateFromCString(
 "func.func @foo(%arg0 : i32) -> i32 {                                   \n"
if (mlirLogicalResultIsFailure(success)) {
       exit(EXIT_FAILURE);
     }
     mlirPassManagerDestroy(pm);
   }
   mlirModuleDestroy(module);
   mlirContextDestroy(ctx);
 }
 
-void testRunPassOnNestedModule() {
+void testRunPassOnNestedModule(void) {
   MlirContext ctx = mlirContextCreate();
   registerAllUpstreamDialects(ctx);
 
   MlirModule module = mlirModuleCreateParse(
       ctx,
       // clang-format off
                             mlirStringRefCreateFromCString(
 "func.func @foo(%arg0 : i32) -> i32 {                                   \n"
static void printToStderr(MlirStringRef str, void *userData) {
   fwrite(str.data, 1, str.length, stderr);
 }
 
 static void dontPrint(MlirStringRef str, void *userData) {
   (void)str;
   (void)userData;
 }
 
-void testPrintPassPipeline() {
+void testPrintPassPipeline(void) {
   MlirContext ctx = mlirContextCreate();
   MlirPassManager pm = mlirPassManagerCreateOnOperation(
       ctx, mlirStringRefCreateFromCString("any"));
   // Populate the pass-manager
   MlirOpPassManager nestedModulePm = mlirPassManagerGetNestedUnder(
       pm, mlirStringRefCreateFromCString("builtin.module"));
   MlirOpPassManager nestedFuncPm = mlirOpPassManagerGetNestedUnder(
       nestedModulePm, mlirStringRefCreateFromCString("func.func"));
void testPrintPassPipeline(void) {
   fprintf(stderr, "Nested Module>Func: ");
   mlirPrintPassPipeline(nestedFuncPm, printToStderr, NULL);
   fprintf(stderr, "\n");
 
   mlirPassManagerDestroy(pm);
   mlirContextDestroy(ctx);
 }
 
-void testParsePassPipeline() {
+void testParsePassPipeline(void) {
   MlirContext ctx = mlirContextCreate();
   MlirPassManager pm = mlirPassManagerCreate(ctx);
   // Try parse a pipeline.
   MlirLogicalResult status = mlirParsePassPipeline(
       mlirPassManagerGetAsOpPassManager(pm),
       mlirStringRefCreateFromCString(
           "builtin.module(func.func(print-op-stats{json=false}))"),
       printToStderr, NULL);
void testParsePassPipeline(void) {
   mlirPrintPassPipeline(mlirPassManagerGetAsOpPassManager(pm), printToStderr,
                         NULL);
   fprintf(stderr, "\n");
 
   mlirPassManagerDestroy(pm);
   mlirContextDestroy(ctx);
 }
 
-void testParseErrorCapture() {
+void testParseErrorCapture(void) {
   // CHECK-LABEL: testParseErrorCapture:
   fprintf(stderr, "\nTEST: testParseErrorCapture:\n");
 
   MlirContext ctx = mlirContextCreate();
   MlirPassManager pm = mlirPassManagerCreate(ctx);
   MlirOpPassManager opm = mlirPassManagerGetAsOpPassManager(pm);
   MlirStringRef invalidPipeline = mlirStringRefCreateFromCString("invalid");
 

 MlirExternalPassCallbacks makeTestExternalPassCallbacks(
     MlirLogicalResult (*initializePass)(MlirContext ctx, void *userData),
     void (*runPass)(MlirOperation op, MlirExternalPass, void *userData)) {
   return (MlirExternalPassCallbacks){testConstructExternalPass,
                                      testDestructExternalPass, initializePass,
                                      testCloneExternalPass, runPass};
 }
 
-void testExternalPass() {
+void testExternalPass(void) {
   MlirContext ctx = mlirContextCreate();
   registerAllUpstreamDialects(ctx);
 
   MlirModule module = mlirModuleCreateParse(
       ctx,
       // clang-format off
       mlirStringRefCreateFromCString(
 "func.func @foo(%arg0 : i32) -> i32 {                                   \n"
// Run a pass that fails during `run`
     }
   }
 
   mlirTypeIDAllocatorDestroy(typeIDAllocator);
   mlirModuleDestroy(module);
   mlirContextDestroy(ctx);
 }
 
-int main() {
+int main(void) {
   testRunPassOnModule();
   testRunPassOnNestedModule();
   testPrintPassPipeline();
   testParsePassPipeline();
   testParseErrorCapture();
   testExternalPass();
   return 0;
 }

mlir/test/CAPI/pdl.c

void testValueType(MlirContext ctx) {
   // CHECK: !pdl.value
   mlirTypeDump(parsedType);
   // CHECK: !pdl.value
   mlirTypeDump(constructedType);
 
   fprintf(stderr, "\n\n");
 }
 
-int main() {
+int main(void) {
   MlirContext ctx = mlirContextCreate();
   mlirDialectHandleRegisterDialect(mlirGetDialectHandle__pdl__(), ctx);
   testAttributeType(ctx);
   testOperationType(ctx);
   testRangeType(ctx);
   testTypeType(ctx);
   testValueType(ctx);
   return EXIT_SUCCESS;
 }

mlir/test/CAPI/quant.c

void testCalibratedType(MlirContext ctx) {
 
   // CHECK: equal: 1
   fprintf(stderr, "equal: %d\n", mlirTypeEqual(calibrated, calibratedParsed));
   // CHECK: !quant.calibrated<f32<-0.998:1.232100e+00>>
   mlirTypeDump(calibrated);
   fprintf(stderr, "\n\n");
 }
 
-int main() {
+int main(void) {
   MlirContext ctx = mlirContextCreate();
   mlirDialectHandleRegisterDialect(mlirGetDialectHandle__quant__(), ctx);
   testTypeHierarchy(ctx);
   testAnyQuantizedType(ctx);
   testUniformType(ctx);
   testUniformPerAxisType(ctx);
   testCalibratedType(ctx);
   mlirContextDestroy(ctx);
   return EXIT_SUCCESS;
 }

mlir/test/CAPI/sparse_tensor.c

static int testRoundtripEncoding(MlirContext ctx) {
   mlirAttributeDump(newAttr); // For debugging filecheck output.
   // CHECK: equal: 1
   fprintf(stderr, "equal: %d\n", mlirAttributeEqual(originalAttr, newAttr));
 
   free(levelTypes);
   return 0;
 }
 
-int main() {
+int main(void) {
   MlirContext ctx = mlirContextCreate();
   mlirDialectHandleRegisterDialect(mlirGetDialectHandle__sparse_tensor__(),
                                    ctx);
   if (testRoundtripEncoding(ctx))
     return 1;
 
   mlirContextDestroy(ctx);
   return 0;
 }

mlir/tools/mlir-tblgen/PassCAPIGen.cpp

static llvm::cl::opt<std::string>
     groupName("prefix",
               llvm::cl::desc("The prefix to use for this group of passes. The "
                              "form will be mlirCreate<prefix><passname>, the "
                              "prefix can avoid conflicts across libraries."),
               llvm::cl::cat(passGenCat));
 
 const char *const passDecl = R"(
 /* Create {0} Pass. */
-MLIR_CAPI_EXPORTED MlirPass mlirCreate{0}{1}();
-MLIR_CAPI_EXPORTED void mlirRegister{0}{1}();
+MLIR_CAPI_EXPORTED MlirPass mlirCreate{0}{1}(void);
+MLIR_CAPI_EXPORTED void mlirRegister{0}{1}(void);
 
 )";
 
 const char *const fileHeader = R"(
 /* Autogenerated by mlir-tblgen; don't manually edit. */
 
 #include "mlir-c/Pass.h"
 

 }
 #endif
 )";
 
 /// Emit TODO
 static bool emitCAPIHeader(const llvm::RecordKeeper &records, raw_ostream &os) {
   os << fileHeader;
   os << "// Registration for the entire group\n";
-  os << "MLIR_CAPI_EXPORTED void mlirRegister" << groupName << "Passes();\n\n";
+  os << "MLIR_CAPI_EXPORTED void mlirRegister" << groupName
+     << "Passes(void);\n\n";
   for (const auto *def : records.getAllDerivedDefinitions("PassBase")) {
     Pass pass(def);
     StringRef defName = pass.getDef()->getName();
     os << llvm::formatv(passDecl, groupName, defName);
   }
   os << fileFooter;
   return false;
 }
 
 const char *const passCreateDef = R"(
-MlirPass mlirCreate{0}{1}() {
+MlirPass mlirCreate{0}{1}(void) {
   return wrap({2}.release());
 }
-void mlirRegister{0}{1}() {
+void mlirRegister{0}{1}(void) {
   register{1}();
 }
 
 )";
 
 /// {0}: The name of the pass group.
 const char *const passGroupRegistrationCode = R"(
 //===----------------------------------------------------------------------===//
 // {0} Group Registration
 //===----------------------------------------------------------------------===//
 
-void mlirRegister{0}Passes() {{
+void mlirRegister{0}Passes(void) {{
   register{0}Passes();
 }
 )";
 
 static bool emitCAPIImpl(const llvm::RecordKeeper &records, raw_ostream &os) {
   os << "/* Autogenerated by mlir-tblgen; don't manually edit. */";
   os << llvm::formatv(passGroupRegistrationCode, groupName);