diff --git a/clang/test/AST/ast-dump-decl-json.m b/clang/test/AST/ast-dump-decl-json.m
index dbe20d8edc73..4a9fa0cfbf06 100644
--- a/clang/test/AST/ast-dump-decl-json.m
+++ b/clang/test/AST/ast-dump-decl-json.m
@@ -79,7 +79,7 @@ void TestBlockDecl(int x) {
 + (int) foo;
 @end
 
-void f() {
+void f(void) {
   __typeof__(B.foo) Test;
 }
 
@@ -1965,7 +1965,7 @@ void f() {
 // CHECK-NOT: {{^}}Dumping
 // CHECK:  "kind": "VarDecl",
 // CHECK-NEXT:  "loc": {
-// CHECK-NEXT:   "offset": 1296,
+// CHECK-NEXT:   "offset": 1300,
 // CHECK-NEXT:   "file": "{{.*}}",
 // CHECK-NEXT:   "line": 83,
 // CHECK-NEXT:   "col": 21,
@@ -1973,12 +1973,12 @@ void f() {
 // CHECK-NEXT:  },
 // CHECK-NEXT:  "range": {
 // CHECK-NEXT:   "begin": {
-// CHECK-NEXT:    "offset": 1278,
+// CHECK-NEXT:    "offset": 1282,
 // CHECK-NEXT:    "col": 3,
 // CHECK-NEXT:    "tokLen": 10
 // CHECK-NEXT:   },
 // CHECK-NEXT:   "end": {
-// CHECK-NEXT:    "offset": 1296,
+// CHECK-NEXT:    "offset": 1300,
 // CHECK-NEXT:    "col": 21,
 // CHECK-NEXT:    "tokLen": 4
 // CHECK-NEXT:   }
diff --git a/clang/test/AST/ast-dump-decl.m b/clang/test/AST/ast-dump-decl.m
index 1e9332b21c72..1157c99e4597 100644
--- a/clang/test/AST/ast-dump-decl.m
+++ b/clang/test/AST/ast-dump-decl.m
@@ -153,7 +153,7 @@ void TestBlockDecl(int x) {
 + (int) foo;
 @end
 
-void f() {
+void f(void) {
   __typeof__(B.foo) Test;
 }
 // CHECK: VarDecl{{.*}}Test 'typeof (B.foo)':'int'
diff --git a/clang/test/AST/ast-dump-openmp-barrier.c b/clang/test/AST/ast-dump-openmp-barrier.c
index 23f3ecbb62ae..a0b8bd2fd3bf 100644
--- a/clang/test/AST/ast-dump-openmp-barrier.c
+++ b/clang/test/AST/ast-dump-openmp-barrier.c
@@ -1,10 +1,10 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
-void test() {
+void test(void) {
 #pragma omp barrier
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-barrier.c:3:1, line:5:1> line:3:6 test 'void ()'
-// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:5:1>
+// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-barrier.c:3:1, line:5:1> line:3:6 test 'void (void)'
+// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:5:1>
 // CHECK-NEXT:     `-OMPBarrierDirective {{.*}} <line:4:1, col:20> openmp_standalone_directive
diff --git a/clang/test/AST/ast-dump-openmp-begin-declare-variant-varying-return.c b/clang/test/AST/ast-dump-openmp-begin-declare-variant-varying-return.c
index dd81e2ee98c1..5c7ff8d75187 100644
--- a/clang/test/AST/ast-dump-openmp-begin-declare-variant-varying-return.c
+++ b/clang/test/AST/ast-dump-openmp-begin-declare-variant-varying-return.c
@@ -62,7 +62,7 @@ RETURN_TY also_after(long l) {
   return AFTER__BASE_RETURN_VALUE;
 }
 
-int main() {
+int main(void) {
   // Should return 0.
   return also_before() + also_before(1) + also_before(2.0f) + also_after(3.0) + also_after(4L);
 }
@@ -123,7 +123,7 @@ int main() {
 // C_FLOAT-NEXT: | |     `-IntegerLiteral [[ADDR_48:0x[a-z0-9]*]] <col:34> 'int' 1
 // C_FLOAT-NEXT: | `-OverloadableAttr [[ADDR_49:0x[a-z0-9]*]] <line:10:37>
 // C_FLOAT-NEXT: `-FunctionDecl [[ADDR_50:0x[a-z0-9]*]] <line:65:1, line:68:1> line:65:5 main 'int ({{.*}})'
-// C_FLOAT-NEXT:   `-CompoundStmt [[ADDR_51:0x[a-z0-9]*]] <col:12, line:68:1>
+// C_FLOAT-NEXT:   `-CompoundStmt [[ADDR_51:0x[a-z0-9]*]] <col:16, line:68:1>
 // C_FLOAT-NEXT:     `-ReturnStmt [[ADDR_52:0x[a-z0-9]*]] <line:67:3, col:94>
 // C_FLOAT-NEXT:       `-ImplicitCastExpr [[ADDR_53:0x[a-z0-9]*]] <col:10, col:94> 'int' <FloatingToIntegral>
 // C_FLOAT-NEXT:         `-BinaryOperator [[ADDR_54:0x[a-z0-9]*]] <col:10, col:94> 'float' '+'
@@ -194,7 +194,7 @@ int main() {
 // CXX_FLOAT-NEXT: |     `-ImplicitCastExpr [[ADDR_40:0x[a-z0-9]*]] <col:34> 'float' <IntegralToFloating>
 // CXX_FLOAT-NEXT: |       `-IntegerLiteral [[ADDR_41:0x[a-z0-9]*]] <col:34> 'int' 1
 // CXX_FLOAT-NEXT: `-FunctionDecl [[ADDR_42:0x[a-z0-9]*]] <line:65:1, line:68:1> line:65:5 main 'int ({{.*}})'
-// CXX_FLOAT-NEXT:   `-CompoundStmt [[ADDR_43:0x[a-z0-9]*]] <col:12, line:68:1>
+// CXX_FLOAT-NEXT:   `-CompoundStmt [[ADDR_43:0x[a-z0-9]*]] <col:16, line:68:1>
 // CXX_FLOAT-NEXT:     `-ReturnStmt [[ADDR_44:0x[a-z0-9]*]] <line:67:3, col:94>
 // CXX_FLOAT-NEXT:       `-ImplicitCastExpr [[ADDR_45:0x[a-z0-9]*]] <col:10, col:94> 'int' <FloatingToIntegral>
 // CXX_FLOAT-NEXT:         `-BinaryOperator [[ADDR_46:0x[a-z0-9]*]] <col:10, col:94> 'float' '+'
@@ -273,7 +273,7 @@ int main() {
 // C_INT-NEXT: | |   `-IntegerLiteral [[ADDR_48:0x[a-z0-9]*]] <col:34> 'int' 0
 // C_INT-NEXT: | `-OverloadableAttr [[ADDR_49:0x[a-z0-9]*]] <line:10:37>
 // C_INT-NEXT: `-FunctionDecl [[ADDR_50:0x[a-z0-9]*]] <line:65:1, line:68:1> line:65:5 main 'int ({{.*}})'
-// C_INT-NEXT:   `-CompoundStmt [[ADDR_51:0x[a-z0-9]*]] <col:12, line:68:1>
+// C_INT-NEXT:   `-CompoundStmt [[ADDR_51:0x[a-z0-9]*]] <col:16, line:68:1>
 // C_INT-NEXT:     `-ReturnStmt [[ADDR_52:0x[a-z0-9]*]] <line:67:3, col:94>
 // C_INT-NEXT:       `-BinaryOperator [[ADDR_53:0x[a-z0-9]*]] <col:10, col:94> 'int' '+'
 // C_INT-NEXT:         |-BinaryOperator [[ADDR_54:0x[a-z0-9]*]] <col:10, col:77> 'int' '+'
@@ -358,7 +358,7 @@ int main() {
 // CXX_INT-NEXT: |   `-ReturnStmt [[ADDR_40:0x[a-z0-9]*]] <line:62:3, line:23:34>
 // CXX_INT-NEXT: |     `-IntegerLiteral [[ADDR_41:0x[a-z0-9]*]] <col:34> 'int' 0
 // CXX_INT-NEXT: `-FunctionDecl [[ADDR_42:0x[a-z0-9]*]] <line:65:1, line:68:1> line:65:5 main 'int ({{.*}})'
-// CXX_INT-NEXT:   `-CompoundStmt [[ADDR_43:0x[a-z0-9]*]] <col:12, line:68:1>
+// CXX_INT-NEXT:   `-CompoundStmt [[ADDR_43:0x[a-z0-9]*]] <col:16, line:68:1>
 // CXX_INT-NEXT:     `-ReturnStmt [[ADDR_44:0x[a-z0-9]*]] <line:67:3, col:94>
 // CXX_INT-NEXT:       `-BinaryOperator [[ADDR_45:0x[a-z0-9]*]] <col:10, col:94> 'int' '+'
 // CXX_INT-NEXT:         |-BinaryOperator [[ADDR_46:0x[a-z0-9]*]] <col:10, col:77> 'int' '+'
diff --git a/clang/test/AST/ast-dump-openmp-begin-declare-variant_1.c b/clang/test/AST/ast-dump-openmp-begin-declare-variant_1.c
index f427049807c6..c017609e2846 100644
--- a/clang/test/AST/ast-dump-openmp-begin-declare-variant_1.c
+++ b/clang/test/AST/ast-dump-openmp-begin-declare-variant_1.c
@@ -26,7 +26,7 @@ int also_after(void) {
   return 0;
 }
 
-int test() {
+int test(void) {
   // Should return 0.
   return also_after() + also_before();
 }
@@ -44,7 +44,7 @@ int test() {
 // CHECK-NEXT: |   `-ReturnStmt [[ADDR_6:0x[a-z0-9]*]] <line:26:3, col:10>
 // CHECK-NEXT: |     `-IntegerLiteral [[ADDR_7:0x[a-z0-9]*]] <col:10> 'int' 0
 // CHECK-NEXT: `-FunctionDecl [[ADDR_8:0x[a-z0-9]*]] <line:29:1, line:32:1> line:29:5 test 'int ({{.*}})'
-// CHECK-NEXT:   `-CompoundStmt [[ADDR_9:0x[a-z0-9]*]] <col:12, line:32:1>
+// CHECK-NEXT:   `-CompoundStmt [[ADDR_9:0x[a-z0-9]*]] <col:16, line:32:1>
 // CHECK-NEXT:     `-ReturnStmt [[ADDR_10:0x[a-z0-9]*]] <line:31:3, col:37>
 // CHECK-NEXT:       `-BinaryOperator [[ADDR_11:0x[a-z0-9]*]] <col:10, col:37> 'int' '+'
 // CHECK-NEXT:         |-CallExpr [[ADDR_12:0x[a-z0-9]*]] <col:10, col:21> 'int'
diff --git a/clang/test/AST/ast-dump-openmp-begin-declare-variant_10.c b/clang/test/AST/ast-dump-openmp-begin-declare-variant_10.c
index fb7347113e77..07274ec67ef4 100644
--- a/clang/test/AST/ast-dump-openmp-begin-declare-variant_10.c
+++ b/clang/test/AST/ast-dump-openmp-begin-declare-variant_10.c
@@ -37,7 +37,7 @@ static CONST __attribute__((nothrow, always_inline)) __inline__ int also_before4
 #pragma omp end declare variant
 
 
-int main() {
+int main(void) {
   // Should return 0.
   return also_before1() + also_before2() + also_before3() + also_before4();
 }
@@ -92,7 +92,7 @@ int main() {
 // C-NEXT: | |-NoThrowAttr [[ADDR_43:0x[a-z0-9]*]] <line:34:29>
 // C-NEXT: | `-AlwaysInlineAttr [[ADDR_44:0x[a-z0-9]*]] <col:38> always_inline
 // C-NEXT: `-FunctionDecl [[ADDR_45:0x[a-z0-9]*]] <line:40:1, line:43:1> line:40:5 main 'int ({{.*}})'
-// C-NEXT:   `-CompoundStmt [[ADDR_46:0x[a-z0-9]*]] <col:12, line:43:1>
+// C-NEXT:   `-CompoundStmt [[ADDR_46:0x[a-z0-9]*]] <col:16, line:43:1>
 // C-NEXT:     `-ReturnStmt [[ADDR_47:0x[a-z0-9]*]] <line:42:3, col:74>
 // C-NEXT:       `-BinaryOperator [[ADDR_48:0x[a-z0-9]*]] <col:10, col:74> 'int' '+'
 // C-NEXT:         |-BinaryOperator [[ADDR_49:0x[a-z0-9]*]] <col:10, col:57> 'int' '+'
@@ -168,7 +168,7 @@ int main() {
 // CXX-NEXT: | |   `-IntegerLiteral [[ADDR_39:0x[a-z0-9]*]] <col:10> 'int' 0
 // CXX-NEXT: | `-AlwaysInlineAttr [[ADDR_40:0x[a-z0-9]*]] <line:34:38> always_inline
 // CXX-NEXT: `-FunctionDecl [[ADDR_41:0x[a-z0-9]*]] <line:40:1, line:43:1> line:40:5 main 'int ({{.*}})'
-// CXX-NEXT:   `-CompoundStmt [[ADDR_42:0x[a-z0-9]*]] <col:12, line:43:1>
+// CXX-NEXT:   `-CompoundStmt [[ADDR_42:0x[a-z0-9]*]] <col:16, line:43:1>
 // CXX-NEXT:     `-ReturnStmt [[ADDR_43:0x[a-z0-9]*]] <line:42:3, col:74>
 // CXX-NEXT:       `-BinaryOperator [[ADDR_44:0x[a-z0-9]*]] <col:10, col:74> 'int' '+'
 // CXX-NEXT:         |-BinaryOperator [[ADDR_45:0x[a-z0-9]*]] <col:10, col:57> 'int' '+'
diff --git a/clang/test/AST/ast-dump-openmp-begin-declare-variant_11.c b/clang/test/AST/ast-dump-openmp-begin-declare-variant_11.c
index 237eedeff389..3e5eb4cb5cd7 100644
--- a/clang/test/AST/ast-dump-openmp-begin-declare-variant_11.c
+++ b/clang/test/AST/ast-dump-openmp-begin-declare-variant_11.c
@@ -38,7 +38,7 @@ int also_after4(void) { // cxx_mode-error {{non-constexpr declaration of 'also_a
 }
 
 
-int main() {
+int main(void) {
   // Should return 0.
   return also_after1() + also_after2() + also_after3() + also_after4();
 }
@@ -115,7 +115,7 @@ int main() {
 // C-NEXT: | `-OMPDeclareVariantAttr [[ADDR_62:0x[a-z0-9]*]] <<invalid sloc>> Inherited Implicit implementation={vendor(llvm)}
 // C-NEXT: |   `-DeclRefExpr [[ADDR_30]] <col:1> 'int ({{.*}})' Function [[ADDR_31]] 'also_after4[implementation={vendor(llvm)}]' 'int ({{.*}})'
 // C-NEXT: `-FunctionDecl [[ADDR_63:0x[a-z0-9]*]] <line:41:1, line:44:1> line:41:5 main 'int ({{.*}})'
-// C-NEXT:   `-CompoundStmt [[ADDR_64:0x[a-z0-9]*]] <col:12, line:44:1>
+// C-NEXT:   `-CompoundStmt [[ADDR_64:0x[a-z0-9]*]] <col:16, line:44:1>
 // C-NEXT:     `-ReturnStmt [[ADDR_65:0x[a-z0-9]*]] <line:43:3, col:70>
 // C-NEXT:       `-BinaryOperator [[ADDR_66:0x[a-z0-9]*]] <col:10, col:70> 'int' '+'
 // C-NEXT:         |-BinaryOperator [[ADDR_67:0x[a-z0-9]*]] <col:10, col:54> 'int' '+'
@@ -205,7 +205,7 @@ int main() {
 // CXX-NEXT: | `-OMPDeclareVariantAttr [[ADDR_50:0x[a-z0-9]*]] <<invalid sloc>> Inherited Implicit implementation={vendor(llvm)}
 // CXX-NEXT: |   `-DeclRefExpr [[ADDR_24]] <col:1> 'int ({{.*}}) __attribute__((nothrow))' Function [[ADDR_25]] 'also_after4[implementation={vendor(llvm)}]' 'int ({{.*}}) __attribute__((nothrow))'
 // CXX-NEXT: `-FunctionDecl [[ADDR_51:0x[a-z0-9]*]] <line:41:1, line:44:1> line:41:5 main 'int ({{.*}})'
-// CXX-NEXT:   `-CompoundStmt [[ADDR_52:0x[a-z0-9]*]] <col:12, line:44:1>
+// CXX-NEXT:   `-CompoundStmt [[ADDR_52:0x[a-z0-9]*]] <col:16, line:44:1>
 // CXX-NEXT:     `-ReturnStmt [[ADDR_53:0x[a-z0-9]*]] <line:43:3, col:70>
 // CXX-NEXT:       `-BinaryOperator [[ADDR_54:0x[a-z0-9]*]] <col:10, col:70> 'int' '+'
 // CXX-NEXT:         |-BinaryOperator [[ADDR_55:0x[a-z0-9]*]] <col:10, col:54> 'int' '+'
diff --git a/clang/test/AST/ast-dump-openmp-begin-declare-variant_12.c b/clang/test/AST/ast-dump-openmp-begin-declare-variant_12.c
index 11fc1e4c8896..55524e052eda 100644
--- a/clang/test/AST/ast-dump-openmp-begin-declare-variant_12.c
+++ b/clang/test/AST/ast-dump-openmp-begin-declare-variant_12.c
@@ -50,7 +50,7 @@ int also_before(long l) {
 #pragma omp end declare variant
 
 
-int main() {
+int main(void) {
   // Should return 0.
   return also_before() + also_before(1) + also_before(2.0f) + also_before(3.0) + also_before(4L);
 }
@@ -120,7 +120,7 @@ int main() {
 // C-NEXT: | |   `-IntegerLiteral [[ADDR_58:0x[a-z0-9]*]] <col:10> 'int' 0
 // C-NEXT: | `-OverloadableAttr [[ADDR_59:0x[a-z0-9]*]] <line:8:37>
 // C-NEXT: `-FunctionDecl [[ADDR_60:0x[a-z0-9]*]] <line:53:1, line:56:1> line:53:5 main 'int ({{.*}})'
-// C-NEXT:   `-CompoundStmt [[ADDR_61:0x[a-z0-9]*]] <col:12, line:56:1>
+// C-NEXT:   `-CompoundStmt [[ADDR_61:0x[a-z0-9]*]] <col:16, line:56:1>
 // C-NEXT:     `-ReturnStmt [[ADDR_62:0x[a-z0-9]*]] <line:55:3, col:96>
 // C-NEXT:       `-BinaryOperator [[ADDR_63:0x[a-z0-9]*]] <col:10, col:96> 'int' '+'
 // C-NEXT:         |-BinaryOperator [[ADDR_64:0x[a-z0-9]*]] <col:10, col:78> 'int' '+'
@@ -217,7 +217,7 @@ int main() {
 // CXX-NEXT: |   `-ReturnStmt [[ADDR_49:0x[a-z0-9]*]] <line:48:3, col:10>
 // CXX-NEXT: |     `-IntegerLiteral [[ADDR_50:0x[a-z0-9]*]] <col:10> 'int' 0
 // CXX-NEXT: `-FunctionDecl [[ADDR_51:0x[a-z0-9]*]] <line:53:1, line:56:1> line:53:5 main 'int ({{.*}})'
-// CXX-NEXT:   `-CompoundStmt [[ADDR_52:0x[a-z0-9]*]] <col:12, line:56:1>
+// CXX-NEXT:   `-CompoundStmt [[ADDR_52:0x[a-z0-9]*]] <col:16, line:56:1>
 // CXX-NEXT:     `-ReturnStmt [[ADDR_53:0x[a-z0-9]*]] <line:55:3, col:96>
 // CXX-NEXT:       `-BinaryOperator [[ADDR_54:0x[a-z0-9]*]] <col:10, col:96> 'int' '+'
 // CXX-NEXT:         |-BinaryOperator [[ADDR_55:0x[a-z0-9]*]] <col:10, col:78> 'int' '+'
diff --git a/clang/test/AST/ast-dump-openmp-begin-declare-variant_13.c b/clang/test/AST/ast-dump-openmp-begin-declare-variant_13.c
index 93d847a07777..a8ffc3826c98 100644
--- a/clang/test/AST/ast-dump-openmp-begin-declare-variant_13.c
+++ b/clang/test/AST/ast-dump-openmp-begin-declare-variant_13.c
@@ -19,7 +19,7 @@ int also_after(void) {
   return 2;
 }
 
-int test() {
+int test(void) {
   // Should return 0.
   return also_after() + also_before();
 }
@@ -48,7 +48,7 @@ int test() {
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_21:0x[a-z0-9]*]] <<invalid sloc>> Inherited Implicit user={condition(1)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_9]] <line:10:1> 'int ({{.*}})' {{.*}}Function [[ADDR_10]] 'also_after[user={condition(...)}]' 'int ({{.*}})'
 // CHECK-NEXT: `-FunctionDecl [[ADDR_22:0x[a-z0-9]*]] <line:22:1, line:25:1> line:22:5 test 'int ({{.*}})'
-// CHECK-NEXT:   `-CompoundStmt [[ADDR_23:0x[a-z0-9]*]] <col:12, line:25:1>
+// CHECK-NEXT:   `-CompoundStmt [[ADDR_23:0x[a-z0-9]*]] <col:16, line:25:1>
 // CHECK-NEXT:     `-ReturnStmt [[ADDR_24:0x[a-z0-9]*]] <line:24:3, col:37>
 // CHECK-NEXT:       `-BinaryOperator [[ADDR_25:0x[a-z0-9]*]] <col:10, col:37> 'int' '+'
 // CHECK-NEXT:         |-PseudoObjectExpr [[ADDR_26:0x[a-z0-9]*]] <col:10, col:21> 'int'
diff --git a/clang/test/AST/ast-dump-openmp-begin-declare-variant_2.c b/clang/test/AST/ast-dump-openmp-begin-declare-variant_2.c
index 8defe3a6f504..e7a30a9d5967 100644
--- a/clang/test/AST/ast-dump-openmp-begin-declare-variant_2.c
+++ b/clang/test/AST/ast-dump-openmp-begin-declare-variant_2.c
@@ -23,7 +23,7 @@ int also_after(void) {
   return 2;
 }
 
-int test() {
+int test(void) {
   // Should return 0.
   return also_after() + also_before();
 }
@@ -60,7 +60,7 @@ int test() {
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_24:0x[a-z0-9]*]] <<invalid sloc>> Inherited Implicit implementation={vendor(score(100): llvm)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_12]] <line:12:1> 'int ({{.*}})' Function [[ADDR_13]] 'also_after[implementation={vendor(llvm)}]' 'int ({{.*}})'
 // CHECK-NEXT: `-FunctionDecl [[ADDR_25:0x[a-z0-9]*]] <line:26:1, line:29:1> line:26:5 test 'int ({{.*}})'
-// CHECK-NEXT:   `-CompoundStmt [[ADDR_26:0x[a-z0-9]*]] <col:12, line:29:1>
+// CHECK-NEXT:   `-CompoundStmt [[ADDR_26:0x[a-z0-9]*]] <col:16, line:29:1>
 // CHECK-NEXT:     `-ReturnStmt [[ADDR_27:0x[a-z0-9]*]] <line:28:3, col:37>
 // CHECK-NEXT:       `-BinaryOperator [[ADDR_28:0x[a-z0-9]*]] <col:10, col:37> 'int' '+'
 // CHECK-NEXT:         |-PseudoObjectExpr [[ADDR_29:0x[a-z0-9]*]] <col:10, col:21> 'int'
diff --git a/clang/test/AST/ast-dump-openmp-begin-declare-variant_3.c b/clang/test/AST/ast-dump-openmp-begin-declare-variant_3.c
index a9b03f82532f..da78f2b08207 100644
--- a/clang/test/AST/ast-dump-openmp-begin-declare-variant_3.c
+++ b/clang/test/AST/ast-dump-openmp-begin-declare-variant_3.c
@@ -23,7 +23,7 @@ int also_after(void) {
   return 2;
 }
 
-int test() {
+int test(void) {
   // Should return 0.
   return also_after() + also_before();
 }
@@ -60,7 +60,7 @@ int test() {
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_24:0x[a-z0-9]*]] <<invalid sloc>> Inherited Implicit implementation={vendor(score(0): llvm)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_12]] <line:12:1> 'int ({{.*}})' Function [[ADDR_13]] 'also_after[implementation={vendor(llvm)}]' 'int ({{.*}})'
 // CHECK-NEXT: `-FunctionDecl [[ADDR_25:0x[a-z0-9]*]] <line:26:1, line:29:1> line:26:5 test 'int ({{.*}})'
-// CHECK-NEXT:   `-CompoundStmt [[ADDR_26:0x[a-z0-9]*]] <col:12, line:29:1>
+// CHECK-NEXT:   `-CompoundStmt [[ADDR_26:0x[a-z0-9]*]] <col:16, line:29:1>
 // CHECK-NEXT:     `-ReturnStmt [[ADDR_27:0x[a-z0-9]*]] <line:28:3, col:37>
 // CHECK-NEXT:       `-BinaryOperator [[ADDR_28:0x[a-z0-9]*]] <col:10, col:37> 'int' '+'
 // CHECK-NEXT:         |-PseudoObjectExpr [[ADDR_29:0x[a-z0-9]*]] <col:10, col:21> 'int'
diff --git a/clang/test/AST/ast-dump-openmp-begin-declare-variant_4.c b/clang/test/AST/ast-dump-openmp-begin-declare-variant_4.c
index b35433478e49..db43c3a25d10 100644
--- a/clang/test/AST/ast-dump-openmp-begin-declare-variant_4.c
+++ b/clang/test/AST/ast-dump-openmp-begin-declare-variant_4.c
@@ -12,7 +12,7 @@ int also_after(void) {
   return 0;
 }
 
-int test() {
+int test(void) {
   // Should return 0.
   return also_after() + also_before();
 }
@@ -33,7 +33,7 @@ int test() {
 // CHECK-NEXT: |   `-ReturnStmt [[ADDR_9:0x[a-z0-9]*]] <line:12:3, col:10>
 // CHECK-NEXT: |     `-IntegerLiteral [[ADDR_10:0x[a-z0-9]*]] <col:10> 'int' 0
 // CHECK-NEXT: `-FunctionDecl [[ADDR_11:0x[a-z0-9]*]] <line:15:1, line:18:1> line:15:5 test 'int ({{.*}})'
-// CHECK-NEXT:   `-CompoundStmt [[ADDR_12:0x[a-z0-9]*]] <col:12, line:18:1>
+// CHECK-NEXT:   `-CompoundStmt [[ADDR_12:0x[a-z0-9]*]] <col:16, line:18:1>
 // CHECK-NEXT:     `-ReturnStmt [[ADDR_13:0x[a-z0-9]*]] <line:17:3, col:37>
 // CHECK-NEXT:       `-BinaryOperator [[ADDR_14:0x[a-z0-9]*]] <col:10, col:37> 'int' '+'
 // CHECK-NEXT:         |-CallExpr [[ADDR_15:0x[a-z0-9]*]] <col:10, col:21> 'int'
diff --git a/clang/test/AST/ast-dump-openmp-begin-declare-variant_5.c b/clang/test/AST/ast-dump-openmp-begin-declare-variant_5.c
index da8e2fa46fa1..d8ca6860a04b 100644
--- a/clang/test/AST/ast-dump-openmp-begin-declare-variant_5.c
+++ b/clang/test/AST/ast-dump-openmp-begin-declare-variant_5.c
@@ -19,7 +19,7 @@ int also_after(void) {
   return 2;
 }
 
-int main() {
+int main(void) {
   // Should return 0.
   return (also_after)() +
          (also_before)() +
@@ -55,7 +55,7 @@ int main() {
 // C-NEXT: | `-OMPDeclareVariantAttr [[ADDR_21:0x[a-z0-9]*]] <<invalid sloc>> Inherited Implicit implementation={vendor(llvm)}
 // C-NEXT: |   `-DeclRefExpr [[ADDR_9]] <line:10:1> 'int ({{.*}})' Function [[ADDR_10]] 'also_after[implementation={vendor(llvm)}]' 'int ({{.*}})'
 // C-NEXT: `-FunctionDecl [[ADDR_22:0x[a-z0-9]*]] <line:22:1, line:28:1> line:22:5 main 'int ({{.*}})'
-// C-NEXT:   `-CompoundStmt [[ADDR_23:0x[a-z0-9]*]] <col:12, line:28:1>
+// C-NEXT:   `-CompoundStmt [[ADDR_23:0x[a-z0-9]*]] <col:16, line:28:1>
 // C-NEXT:     `-ReturnStmt [[ADDR_24:0x[a-z0-9]*]] <line:24:3, line:27:25>
 // C-NEXT:       `-BinaryOperator [[ADDR_25:0x[a-z0-9]*]] <line:24:10, line:27:25> 'int' '+'
 // C-NEXT:         |-BinaryOperator [[ADDR_26:0x[a-z0-9]*]] <line:24:10, line:26:24> 'int' '+'
@@ -117,7 +117,7 @@ int main() {
 // CXX-NEXT: | `-OMPDeclareVariantAttr [[ADDR_21:0x[a-z0-9]*]] <<invalid sloc>> Inherited Implicit implementation={vendor(llvm)}
 // CXX-NEXT: |   `-DeclRefExpr [[ADDR_9]] <line:10:1> 'int ({{.*}})' Function [[ADDR_10]] 'also_after[implementation={vendor(llvm)}]' 'int ({{.*}})'
 // CXX-NEXT: `-FunctionDecl [[ADDR_22:0x[a-z0-9]*]] <line:22:1, line:28:1> line:22:5 main 'int ({{.*}})'
-// CXX-NEXT:   `-CompoundStmt [[ADDR_23:0x[a-z0-9]*]] <col:12, line:28:1>
+// CXX-NEXT:   `-CompoundStmt [[ADDR_23:0x[a-z0-9]*]] <col:16, line:28:1>
 // CXX-NEXT:     `-ReturnStmt [[ADDR_24:0x[a-z0-9]*]] <line:24:3, line:27:25>
 // CXX-NEXT:       `-BinaryOperator [[ADDR_25:0x[a-z0-9]*]] <line:24:10, line:27:25> 'int' '+'
 // CXX-NEXT:         |-BinaryOperator [[ADDR_26:0x[a-z0-9]*]] <line:24:10, line:26:24> 'int' '+'
diff --git a/clang/test/AST/ast-dump-openmp-begin-declare-variant_6.c b/clang/test/AST/ast-dump-openmp-begin-declare-variant_6.c
index f221ae839cec..92a5157a9a3a 100644
--- a/clang/test/AST/ast-dump-openmp-begin-declare-variant_6.c
+++ b/clang/test/AST/ast-dump-openmp-begin-declare-variant_6.c
@@ -19,7 +19,7 @@ int also_after(void) {
   return 0;
 }
 
-int main() {
+int main(void) {
   // Should return 0.
   return also_after() + also_before();
 }
@@ -52,7 +52,7 @@ int main() {
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_21:0x[a-z0-9]*]] <<invalid sloc>> Inherited Implicit implementation={vendor(ibm)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_9]] <line:10:1> 'int ({{.*}})' Function [[ADDR_10]] 'also_after[implementation={vendor(ibm)}]' 'int ({{.*}})'
 // CHECK-NEXT: `-FunctionDecl [[ADDR_22:0x[a-z0-9]*]] <line:22:1, line:25:1> line:22:5 main 'int ({{.*}})'
-// CHECK-NEXT:   `-CompoundStmt [[ADDR_23:0x[a-z0-9]*]] <col:12, line:25:1>
+// CHECK-NEXT:   `-CompoundStmt [[ADDR_23:0x[a-z0-9]*]] <col:16, line:25:1>
 // CHECK-NEXT:     `-ReturnStmt [[ADDR_24:0x[a-z0-9]*]] <line:24:3, col:37>
 // CHECK-NEXT:       `-BinaryOperator [[ADDR_25:0x[a-z0-9]*]] <col:10, col:37> 'int' '+'
 // CHECK-NEXT:         |-CallExpr [[ADDR_26:0x[a-z0-9]*]] <col:10, col:21> 'int'
diff --git a/clang/test/AST/ast-dump-openmp-begin-declare-variant_7.c b/clang/test/AST/ast-dump-openmp-begin-declare-variant_7.c
index baf30444242f..4cf4e9989f13 100644
--- a/clang/test/AST/ast-dump-openmp-begin-declare-variant_7.c
+++ b/clang/test/AST/ast-dump-openmp-begin-declare-variant_7.c
@@ -21,7 +21,7 @@ int OK_3(void) {
 
 int OK_3(void);
 
-int test() {
+int test(void) {
   // Should cause an error due to not_OK()
   return OK_1() + not_OK() + OK_3();
 }
@@ -66,7 +66,7 @@ int test() {
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_29:0x[a-z0-9]*]] <<invalid sloc>> Inherited Implicit implementation={vendor(intel)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_23]] <line:17:1> 'int ({{.*}})' Function [[ADDR_24]] 'OK_3[implementation={vendor(intel)}]' 'int ({{.*}})'
 // CHECK-NEXT: `-FunctionDecl [[ADDR_30:0x[a-z0-9]*]] <line:24:1, line:27:1> line:24:5 test 'int ({{.*}})'
-// CHECK-NEXT:   `-CompoundStmt [[ADDR_31:0x[a-z0-9]*]] <col:12, line:27:1>
+// CHECK-NEXT:   `-CompoundStmt [[ADDR_31:0x[a-z0-9]*]] <col:16, line:27:1>
 // CHECK-NEXT:     `-ReturnStmt [[ADDR_32:0x[a-z0-9]*]] <line:26:3, col:35>
 // CHECK-NEXT:       `-BinaryOperator [[ADDR_33:0x[a-z0-9]*]] <col:10, col:35> 'int' '+'
 // CHECK-NEXT:         |-BinaryOperator [[ADDR_34:0x[a-z0-9]*]] <col:10, col:26> 'int' '+'
diff --git a/clang/test/AST/ast-dump-openmp-begin-declare-variant_8.c b/clang/test/AST/ast-dump-openmp-begin-declare-variant_8.c
index a9b03f82532f..da78f2b08207 100644
--- a/clang/test/AST/ast-dump-openmp-begin-declare-variant_8.c
+++ b/clang/test/AST/ast-dump-openmp-begin-declare-variant_8.c
@@ -23,7 +23,7 @@ int also_after(void) {
   return 2;
 }
 
-int test() {
+int test(void) {
   // Should return 0.
   return also_after() + also_before();
 }
@@ -60,7 +60,7 @@ int test() {
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_24:0x[a-z0-9]*]] <<invalid sloc>> Inherited Implicit implementation={vendor(score(0): llvm)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_12]] <line:12:1> 'int ({{.*}})' Function [[ADDR_13]] 'also_after[implementation={vendor(llvm)}]' 'int ({{.*}})'
 // CHECK-NEXT: `-FunctionDecl [[ADDR_25:0x[a-z0-9]*]] <line:26:1, line:29:1> line:26:5 test 'int ({{.*}})'
-// CHECK-NEXT:   `-CompoundStmt [[ADDR_26:0x[a-z0-9]*]] <col:12, line:29:1>
+// CHECK-NEXT:   `-CompoundStmt [[ADDR_26:0x[a-z0-9]*]] <col:16, line:29:1>
 // CHECK-NEXT:     `-ReturnStmt [[ADDR_27:0x[a-z0-9]*]] <line:28:3, col:37>
 // CHECK-NEXT:       `-BinaryOperator [[ADDR_28:0x[a-z0-9]*]] <col:10, col:37> 'int' '+'
 // CHECK-NEXT:         |-PseudoObjectExpr [[ADDR_29:0x[a-z0-9]*]] <col:10, col:21> 'int'
diff --git a/clang/test/AST/ast-dump-openmp-begin-declare-variant_9.c b/clang/test/AST/ast-dump-openmp-begin-declare-variant_9.c
index 41b70edaf0c8..02f73538a978 100644
--- a/clang/test/AST/ast-dump-openmp-begin-declare-variant_9.c
+++ b/clang/test/AST/ast-dump-openmp-begin-declare-variant_9.c
@@ -19,9 +19,9 @@ int also_after(void) {
   return 0;
 }
 
-void foo();
+void foo(void);
 typedef int(*fd)(void);
-int main() {
+int main(void) {
   // Should return 0.
   fd fns[2];
   fns[0] = &also_before;
@@ -58,14 +58,14 @@ int main() {
 // C-NEXT: | |   `-IntegerLiteral [[ADDR_20:0x[a-z0-9]*]] <col:10> 'int' 0
 // C-NEXT: | `-OMPDeclareVariantAttr [[ADDR_21:0x[a-z0-9]*]] <<invalid sloc>> Inherited Implicit implementation={vendor(llvm)}
 // C-NEXT: |   `-DeclRefExpr [[ADDR_9]] <line:10:1> 'int ({{.*}})' Function [[ADDR_10]] 'also_after[implementation={vendor(llvm)}]' 'int ({{.*}})'
-// C-NEXT: |-FunctionDecl [[ADDR_22:0x[a-z0-9]*]] <line:22:1, col:10> col:6 used foo 'void ({{.*}})'
+// C-NEXT: |-FunctionDecl [[ADDR_22:0x[a-z0-9]*]] <line:22:1, col:14> col:6 used foo 'void ({{.*}})'
 // C-NEXT: |-TypedefDecl [[ADDR_23:0x[a-z0-9]*]] <line:23:1, col:22> col:14 referenced fd 'int (*)({{.*}})'
 // C-NEXT: | `-PointerType [[ADDR_24:0x[a-z0-9]*]] 'int (*)({{.*}})'
 // C-NEXT: |   `-ParenType [[ADDR_25:0x[a-z0-9]*]] 'int ({{.*}})' sugar
 // C-NEXT: |     `-FunctionProtoType [[ADDR_26:0x[a-z0-9]*]] 'int ({{.*}})' cdecl
 // C-NEXT: |       `-BuiltinType [[ADDR_27:0x[a-z0-9]*]] 'int'
 // C-NEXT: `-FunctionDecl [[ADDR_28:0x[a-z0-9]*]] <line:24:1, line:32:1> line:24:5 main 'int ({{.*}})'
-// C-NEXT:   `-CompoundStmt [[ADDR_29:0x[a-z0-9]*]] <col:12, line:32:1>
+// C-NEXT:   `-CompoundStmt [[ADDR_29:0x[a-z0-9]*]] <col:16, line:32:1>
 // C-NEXT:     |-DeclStmt [[ADDR_30:0x[a-z0-9]*]] <line:26:3, col:12>
 // C-NEXT:     | `-VarDecl [[ADDR_31:0x[a-z0-9]*]] <col:3, col:11> col:6 used fns 'fd[2]'
 // C-NEXT:     |-BinaryOperator [[ADDR_32:0x[a-z0-9]*]] <line:27:3, col:13> 'fd':'int (*)({{.*}})' '='
@@ -131,14 +131,14 @@ int main() {
 // CXX-NEXT: | |   `-IntegerLiteral [[ADDR_20:0x[a-z0-9]*]] <col:10> 'int' 0
 // CXX-NEXT: | `-OMPDeclareVariantAttr [[ADDR_21:0x[a-z0-9]*]] <<invalid sloc>> Inherited Implicit implementation={vendor(llvm)}
 // CXX-NEXT: |   `-DeclRefExpr [[ADDR_9]] <line:10:1> 'int ({{.*}})' Function [[ADDR_10]] 'also_after[implementation={vendor(llvm)}]' 'int ({{.*}})'
-// CXX-NEXT: |-FunctionDecl [[ADDR_22:0x[a-z0-9]*]] <line:22:1, col:10> col:6 used foo 'void ({{.*}})'
+// CXX-NEXT: |-FunctionDecl [[ADDR_22:0x[a-z0-9]*]] <line:22:1, col:14> col:6 used foo 'void ({{.*}})'
 // CXX-NEXT: |-TypedefDecl [[ADDR_23:0x[a-z0-9]*]] <line:23:1, col:22> col:14 referenced fd 'int (*)({{.*}})'
 // CXX-NEXT: | `-PointerType [[ADDR_24:0x[a-z0-9]*]] 'int (*)({{.*}})'
 // CXX-NEXT: |   `-ParenType [[ADDR_25:0x[a-z0-9]*]] 'int ({{.*}})' sugar
 // CXX-NEXT: |     `-FunctionProtoType [[ADDR_26:0x[a-z0-9]*]] 'int ({{.*}})' cdecl
 // CXX-NEXT: |       `-BuiltinType [[ADDR_27:0x[a-z0-9]*]] 'int'
 // CXX-NEXT: `-FunctionDecl [[ADDR_28:0x[a-z0-9]*]] <line:24:1, line:32:1> line:24:5 main 'int ({{.*}})'
-// CXX-NEXT:   `-CompoundStmt [[ADDR_29:0x[a-z0-9]*]] <col:12, line:32:1>
+// CXX-NEXT:   `-CompoundStmt [[ADDR_29:0x[a-z0-9]*]] <col:16, line:32:1>
 // CXX-NEXT:     |-DeclStmt [[ADDR_30:0x[a-z0-9]*]] <line:26:3, col:12>
 // CXX-NEXT:     | `-VarDecl [[ADDR_31:0x[a-z0-9]*]] <col:3, col:11> col:6 used fns 'fd[2]'
 // CXX-NEXT:     |-BinaryOperator [[ADDR_32:0x[a-z0-9]*]] <line:27:3, col:13> 'fd':'int (*)({{.*}})' {{.*}}'='
diff --git a/clang/test/AST/ast-dump-openmp-begin-declare-variant_addr_1.c b/clang/test/AST/ast-dump-openmp-begin-declare-variant_addr_1.c
index 903cd794f998..0b082007ba80 100644
--- a/clang/test/AST/ast-dump-openmp-begin-declare-variant_addr_1.c
+++ b/clang/test/AST/ast-dump-openmp-begin-declare-variant_addr_1.c
@@ -22,7 +22,7 @@ int also_after(void) {
 int test(int (*fd)(void)) {
   return fd();
 }
-int main() {
+int main(void) {
   // Should return 0.
   return test(also_after) +
          test(also_before) +
@@ -65,7 +65,7 @@ int main() {
 // CHECK-NEXT: |       `-ImplicitCastExpr [[ADDR_27:0x[a-z0-9]*]] <col:10> 'int (*)({{.*}})' <LValueToRValue>
 // CHECK-NEXT: |         `-DeclRefExpr [[ADDR_28:0x[a-z0-9]*]] <col:10> 'int (*)({{.*}})' {{.*}}ParmVar [[ADDR_23]] 'fd' 'int (*)({{.*}})'
 // CHECK-NEXT: `-FunctionDecl [[ADDR_29:0x[a-z0-9]*]] <line:25:1, line:31:1> line:25:5 main 'int ({{.*}})'
-// CHECK-NEXT:   `-CompoundStmt [[ADDR_30:0x[a-z0-9]*]] <col:12, line:31:1>
+// CHECK-NEXT:   `-CompoundStmt [[ADDR_30:0x[a-z0-9]*]] <col:16, line:31:1>
 // CHECK-NEXT:     `-ReturnStmt [[ADDR_31:0x[a-z0-9]*]] <line:27:3, line:30:27>
 // CHECK-NEXT:       `-BinaryOperator [[ADDR_32:0x[a-z0-9]*]] <line:27:10, line:30:27> 'int' '+'
 // CHECK-NEXT:         |-BinaryOperator [[ADDR_33:0x[a-z0-9]*]] <line:27:10, line:29:26> 'int' '+'
diff --git a/clang/test/AST/ast-dump-openmp-begin-declare-variant_decl_1.c b/clang/test/AST/ast-dump-openmp-begin-declare-variant_decl_1.c
index 2cf28058703c..bbf945e6179f 100644
--- a/clang/test/AST/ast-dump-openmp-begin-declare-variant_decl_1.c
+++ b/clang/test/AST/ast-dump-openmp-begin-declare-variant_decl_1.c
@@ -20,7 +20,7 @@ int also_after(void) {
   return 0;
 }
 
-int test() {
+int test(void) {
   // Should return 0.
   return also_after() + also_before();
 }
@@ -42,7 +42,7 @@ int test() {
 // CHECK-NEXT: |   `-ReturnStmt [[ADDR_9:0x[a-z0-9]*]] <line:20:3, col:10>
 // CHECK-NEXT: |     `-IntegerLiteral [[ADDR_10:0x[a-z0-9]*]] <col:10> 'int' 0
 // CHECK-NEXT: `-FunctionDecl [[ADDR_11:0x[a-z0-9]*]] <line:23:1, line:26:1> line:23:5 test 'int ({{.*}})'
-// CHECK-NEXT:   `-CompoundStmt [[ADDR_12:0x[a-z0-9]*]] <col:12, line:26:1>
+// CHECK-NEXT:   `-CompoundStmt [[ADDR_12:0x[a-z0-9]*]] <col:16, line:26:1>
 // CHECK-NEXT:     `-ReturnStmt [[ADDR_13:0x[a-z0-9]*]] <line:25:3, col:37>
 // CHECK-NEXT:       `-BinaryOperator [[ADDR_14:0x[a-z0-9]*]] <col:10, col:37> 'int' '+'
 // CHECK-NEXT:         |-CallExpr [[ADDR_15:0x[a-z0-9]*]] <col:10, col:21> 'int'
diff --git a/clang/test/AST/ast-dump-openmp-begin-declare-variant_nested.c b/clang/test/AST/ast-dump-openmp-begin-declare-variant_nested.c
index e4b5b39ae87a..11bd51e7443b 100644
--- a/clang/test/AST/ast-dump-openmp-begin-declare-variant_nested.c
+++ b/clang/test/AST/ast-dump-openmp-begin-declare-variant_nested.c
@@ -23,7 +23,7 @@ int also_after(void) {
   return 2;
 }
 
-int test() {
+int test(void) {
   // Should return 0.
   return also_after() + also_before();
 }
@@ -62,7 +62,7 @@ int non_equivalent_isa_trait(void);
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_21:0x[a-z0-9]*]] <<invalid sloc>> Inherited Implicit device={kind(any, cpu)}, implementation={dynamic_allocators, vendor(llvm, pgi), extension(match_any)}, user={condition(1)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_9]] <line:12:1> 'int ({{.*}})' {{.*}}Function [[ADDR_10]] 'also_after[device={kind(any, cpu)}, implementation={dynamic_allocators, vendor(llvm, pgi), extension(match_any)}, user={condition(...)}]' 'int ({{.*}})'
 // CHECK-NEXT: |-FunctionDecl [[ADDR_22:0x[a-z0-9]*]] <line:26:1, line:29:1> line:26:5 referenced test 'int ({{.*}})'
-// CHECK-NEXT: | `-CompoundStmt [[ADDR_23:0x[a-z0-9]*]] <col:12, line:29:1>
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_23:0x[a-z0-9]*]] <col:16, line:29:1>
 // CHECK-NEXT: |   `-ReturnStmt [[ADDR_24:0x[a-z0-9]*]] <line:28:3, col:37>
 // CHECK-NEXT: |     `-BinaryOperator [[ADDR_25:0x[a-z0-9]*]] <col:10, col:37> 'int' '+'
 // CHECK-NEXT: |       |-PseudoObjectExpr [[ADDR_26:0x[a-z0-9]*]] <col:10, col:21> 'int'
diff --git a/clang/test/AST/ast-dump-openmp-cancel.c b/clang/test/AST/ast-dump-openmp-cancel.c
index 785cddbe876b..ce695b150792 100644
--- a/clang/test/AST/ast-dump-openmp-cancel.c
+++ b/clang/test/AST/ast-dump-openmp-cancel.c
@@ -1,6 +1,6 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
-void test() {
+void test(void) {
 #pragma omp parallel
   {
 #pragma omp cancel parallel
@@ -8,8 +8,8 @@ void test() {
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-cancel.c:3:1, line:8:1> line:3:6 test 'void ()'
-// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:8:1>
+// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-cancel.c:3:1, line:8:1> line:3:6 test 'void (void)'
+// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:8:1>
 // CHECK-NEXT:     `-OMPParallelDirective {{.*}} <line:4:1, col:21>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3, line:7:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
diff --git a/clang/test/AST/ast-dump-openmp-cancellation-point.c b/clang/test/AST/ast-dump-openmp-cancellation-point.c
index 1fdb8f20647e..62cd23695080 100644
--- a/clang/test/AST/ast-dump-openmp-cancellation-point.c
+++ b/clang/test/AST/ast-dump-openmp-cancellation-point.c
@@ -1,6 +1,6 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
-void test() {
+void test(void) {
 #pragma omp parallel
   {
 #pragma omp cancellation point parallel
@@ -8,8 +8,8 @@ void test() {
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-cancellation-point.c:3:1, line:8:1> line:3:6 test 'void ()'
-// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:8:1>
+// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-cancellation-point.c:3:1, line:8:1> line:3:6 test 'void (void)'
+// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:8:1>
 // CHECK-NEXT:     `-OMPParallelDirective {{.*}} <line:4:1, col:21>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3, line:7:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
diff --git a/clang/test/AST/ast-dump-openmp-critical.c b/clang/test/AST/ast-dump-openmp-critical.c
index d4d3efe3e8a4..7b2ff1567764 100644
--- a/clang/test/AST/ast-dump-openmp-critical.c
+++ b/clang/test/AST/ast-dump-openmp-critical.c
@@ -1,12 +1,12 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
-void test() {
+void test(void) {
 #pragma omp critical
   ;
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-critical.c:3:1, line:6:1> line:3:6 test 'void ()'
-// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:6:1>
+// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-critical.c:3:1, line:6:1> line:3:6 test 'void (void)'
+// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:6:1>
 // CHECK-NEXT:     `-OMPCriticalDirective {{.*}} <line:4:1, col:21>
 // CHECK-NEXT:       `-NullStmt {{.*}} <line:5:3>
diff --git a/clang/test/AST/ast-dump-openmp-declare-variant-extensions-messages.c b/clang/test/AST/ast-dump-openmp-declare-variant-extensions-messages.c
index 7d5e668ddf33..f13615d2c2ec 100644
--- a/clang/test/AST/ast-dump-openmp-declare-variant-extensions-messages.c
+++ b/clang/test/AST/ast-dump-openmp-declare-variant-extensions-messages.c
@@ -1,18 +1,18 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -verify %s
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -verify %s -x c++
 
-int dummy() { return 1; }
+int dummy(void) { return 1; }
 
 #pragma omp declare variant(dummy) match(implementation={extension(match_any,match_all)}, device={kind(cpu, gpu)}) // expected-error {{only a single match extension allowed per OpenMP context selector}} expected-note {{the previous context property 'match_any' used here}} // expected-note {{the ignored property spans until here}}
-int base1() { return 2; }
+int base1(void) { return 2; }
 
 #pragma omp declare variant(dummy) match(implementation={extension(match_none,match_none)}, device={kind(gpu, fpga)}) // expected-warning {{the context property 'match_none' was used already in the same 'omp declare variant' directive; property ignored}} expected-note {{the previous context property 'match_none' used here}} expected-note {{the ignored property spans until here}}
-int base2() { return 3; }
+int base2(void) { return 3; }
 
 #pragma omp declare variant(dummy) match(implementation={vendor(pgi), extension(match_none,match_any)}, device={kind(cpu, gpu)}) // expected-error {{only a single match extension allowed per OpenMP context selector}} expected-note {{the previous context property 'match_none' used here}} // expected-note {{the ignored property spans until here}}
-int base3() { return 4; }
+int base3(void) { return 4; }
 
 
-int test() {
+int test(void) {
   return base1() + base2() + base3();
 }
diff --git a/clang/test/AST/ast-dump-openmp-declare-variant-extensions.c b/clang/test/AST/ast-dump-openmp-declare-variant-extensions.c
index 577abbc5fe0b..c2a863b16b3f 100644
--- a/clang/test/AST/ast-dump-openmp-declare-variant-extensions.c
+++ b/clang/test/AST/ast-dump-openmp-declare-variant-extensions.c
@@ -2,66 +2,66 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -verify -ast-dump %s -x c++| FileCheck %s
 // expected-no-diagnostics
 
-int picked1() { return 0; }
-int picked2() { return 0; }
-int picked3();
-int picked4();
-int picked5() { return 0; }
-int picked6() { return 0; }
-int picked7() { return 0; }
-int not_picked1() { return 1; }
-int not_picked2() { return 2; }
-int not_picked3();
-int not_picked4();
-int not_picked5();
-int not_picked6();
+int picked1(void) { return 0; }
+int picked2(void) { return 0; }
+int picked3(void);
+int picked4(void);
+int picked5(void) { return 0; }
+int picked6(void) { return 0; }
+int picked7(void) { return 0; }
+int not_picked1(void) { return 1; }
+int not_picked2(void) { return 2; }
+int not_picked3(void);
+int not_picked4(void);
+int not_picked5(void);
+int not_picked6(void);
 
 #pragma omp declare variant(picked1) match(implementation={extension(match_any)}, device={kind(cpu, gpu)})
-int base1() { return 3; }
+int base1(void) { return 3; }
 
 #pragma omp declare variant(picked2) match(implementation={extension(match_none)}, device={kind(gpu, fpga)})
-int base2() { return 4; }
+int base2(void) { return 4; }
 
 #pragma omp declare variant(picked3) match(implementation={vendor(pgi), extension(match_any)}, device={kind(cpu, gpu)})
-int base3() { return 5; }
+int base3(void) { return 5; }
 
 #pragma omp declare variant(picked4) match(user={condition(0)}, implementation={extension(match_none)}, device={kind(gpu, fpga)})
-int base4() { return 6; }
+int base4(void) { return 6; }
 
 #pragma omp declare variant(picked5) match(user={condition(1)}, implementation={extension(match_all)}, device={kind(cpu)})
-int base5() { return 7; }
+int base5(void) { return 7; }
 
 #pragma omp declare variant(not_picked1) match(implementation={extension(match_any)}, device={kind(gpu, fpga)})
-int base6() { return 0; }
+int base6(void) { return 0; }
 
 #pragma omp declare variant(not_picked2) match(implementation={extension(match_none)}, device={kind(gpu, cpu)})
-int base7() { return 0; }
+int base7(void) { return 0; }
 
 #pragma omp declare variant(not_picked3) match(implementation={vendor(llvm), extension(match_any)}, device={kind(fpga, gpu)})
-int base8() { return 0; }
+int base8(void) { return 0; }
 
 #pragma omp declare variant(not_picked4) match(user={condition(1)}, implementation={extension(match_none)}, device={kind(gpu, fpga)})
-int base9() { return 0; }
+int base9(void) { return 0; }
 
 #pragma omp declare variant(not_picked5) match(user={condition(1)}, implementation={extension(match_all)}, device={kind(cpu, gpu)})
-int base10() { return 0; }
+int base10(void) { return 0; }
 
 #pragma omp declare variant(not_picked6) match(implementation={extension(match_any)})
-int base11() { return 0; }
+int base11(void) { return 0; }
 
 #pragma omp declare variant(picked6) match(implementation={extension(match_all)})
-int base12() { return 8; }
+int base12(void) { return 8; }
 
 #pragma omp declare variant(picked7) match(implementation={extension(match_none)})
-int base13() { return 9; }
+int base13(void) { return 9; }
 
 #pragma omp begin declare variant match(implementation={extension(match_any)}, device={kind(cpu, gpu)})
-int overloaded1() { return 0; }
+int overloaded1(void) { return 0; }
 #pragma omp end declare variant
 
-int overloaded2() { return 1; }
+int overloaded2(void) { return 1; }
 #pragma omp begin declare variant match(implementation={extension(match_none)}, device={kind(fpga, gpu)})
-int overloaded2() { return 0; }
+int overloaded2(void) { return 0; }
 #pragma omp end declare variant
 
 #pragma omp begin declare variant match(implementation={extension(match_none)}, device={kind(cpu)})
@@ -69,14 +69,14 @@ NOT PARSED
 #pragma omp end declare variant
 
 
-int picked3() { return 0; }
-int picked4() { return 0; }
-int not_picked3() { return 10; }
-int not_picked4() { return 11; }
-int not_picked5() { return 12; }
-int not_picked6() { return 13; }
+int picked3(void) { return 0; }
+int picked4(void) { return 0; }
+int not_picked3(void) { return 10; }
+int not_picked4(void) { return 11; }
+int not_picked5(void) { return 12; }
+int not_picked6(void) { return 13; }
 
-int test() {
+int test(void) {
   // Should return 0.
   return base1() + base2() + base3() + base4() + base5() + base6() + base7() +
          base8() + base9() + base10() + base11() + base12() + base13() +
@@ -86,161 +86,161 @@ int test() {
 // 1) All "picked" versions are called but none of the "non_picked" ones is.
 // 2) The overloaded functions that return 0 are called.
 
-// CHECK:      |-FunctionDecl [[ADDR_0:0x[a-z0-9]*]] <{{.*}}, col:27> col:5 referenced picked1 'int ({{.*}})'
-// CHECK-NEXT: | `-CompoundStmt [[ADDR_1:0x[a-z0-9]*]] <col:15, col:27>
-// CHECK-NEXT: |   `-ReturnStmt [[ADDR_2:0x[a-z0-9]*]] <col:17, col:24>
-// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_3:0x[a-z0-9]*]] <col:24> 'int' 0
-// CHECK-NEXT: |-FunctionDecl [[ADDR_4:0x[a-z0-9]*]] <line:6:1, col:27> col:5 referenced picked2 'int ({{.*}})'
-// CHECK-NEXT: | `-CompoundStmt [[ADDR_5:0x[a-z0-9]*]] <col:15, col:27>
-// CHECK-NEXT: |   `-ReturnStmt [[ADDR_6:0x[a-z0-9]*]] <col:17, col:24>
-// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_7:0x[a-z0-9]*]] <col:24> 'int' 0
-// CHECK-NEXT: |-FunctionDecl [[ADDR_8:0x[a-z0-9]*]] <line:7:1, col:13> col:5 referenced picked3 'int ({{.*}})'
-// CHECK-NEXT: |-FunctionDecl [[ADDR_9:0x[a-z0-9]*]] <line:8:1, col:13> col:5 referenced picked4 'int ({{.*}})'
-// CHECK-NEXT: |-FunctionDecl [[ADDR_10:0x[a-z0-9]*]] <line:9:1, col:27> col:5 referenced picked5 'int ({{.*}})'
-// CHECK-NEXT: | `-CompoundStmt [[ADDR_11:0x[a-z0-9]*]] <col:15, col:27>
-// CHECK-NEXT: |   `-ReturnStmt [[ADDR_12:0x[a-z0-9]*]] <col:17, col:24>
-// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_13:0x[a-z0-9]*]] <col:24> 'int' 0
-// CHECK-NEXT: |-FunctionDecl [[ADDR_14:0x[a-z0-9]*]] <line:10:1, col:27> col:5 referenced picked6 'int ({{.*}})'
-// CHECK-NEXT: | `-CompoundStmt [[ADDR_15:0x[a-z0-9]*]] <col:15, col:27>
-// CHECK-NEXT: |   `-ReturnStmt [[ADDR_16:0x[a-z0-9]*]] <col:17, col:24>
-// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_17:0x[a-z0-9]*]] <col:24> 'int' 0
-// CHECK-NEXT: |-FunctionDecl [[ADDR_18:0x[a-z0-9]*]] <line:11:1, col:27> col:5 referenced picked7 'int ({{.*}})'
-// CHECK-NEXT: | `-CompoundStmt [[ADDR_19:0x[a-z0-9]*]] <col:15, col:27>
-// CHECK-NEXT: |   `-ReturnStmt [[ADDR_20:0x[a-z0-9]*]] <col:17, col:24>
-// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_21:0x[a-z0-9]*]] <col:24> 'int' 0
-// CHECK-NEXT: |-FunctionDecl [[ADDR_22:0x[a-z0-9]*]] <line:12:1, col:31> col:5 referenced not_picked1 'int ({{.*}})'
-// CHECK-NEXT: | `-CompoundStmt [[ADDR_23:0x[a-z0-9]*]] <col:19, col:31>
-// CHECK-NEXT: |   `-ReturnStmt [[ADDR_24:0x[a-z0-9]*]] <col:21, col:28>
-// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_25:0x[a-z0-9]*]] <col:28> 'int' 1
-// CHECK-NEXT: |-FunctionDecl [[ADDR_26:0x[a-z0-9]*]] <line:13:1, col:31> col:5 referenced not_picked2 'int ({{.*}})'
-// CHECK-NEXT: | `-CompoundStmt [[ADDR_27:0x[a-z0-9]*]] <col:19, col:31>
-// CHECK-NEXT: |   `-ReturnStmt [[ADDR_28:0x[a-z0-9]*]] <col:21, col:28>
-// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_29:0x[a-z0-9]*]] <col:28> 'int' 2
-// CHECK-NEXT: |-FunctionDecl [[ADDR_30:0x[a-z0-9]*]] <line:14:1, col:17> col:5 referenced not_picked3 'int ({{.*}})'
-// CHECK-NEXT: |-FunctionDecl [[ADDR_31:0x[a-z0-9]*]] <line:15:1, col:17> col:5 referenced not_picked4 'int ({{.*}})'
-// CHECK-NEXT: |-FunctionDecl [[ADDR_32:0x[a-z0-9]*]] <line:16:1, col:17> col:5 referenced not_picked5 'int ({{.*}})'
-// CHECK-NEXT: |-FunctionDecl [[ADDR_33:0x[a-z0-9]*]] <line:17:1, col:17> col:5 referenced not_picked6 'int ({{.*}})'
-// CHECK-NEXT: |-FunctionDecl [[ADDR_34:0x[a-z0-9]*]] <line:20:1, col:25> col:5 used base1 'int ({{.*}})'
-// CHECK-NEXT: | |-CompoundStmt [[ADDR_35:0x[a-z0-9]*]] <col:13, col:25>
-// CHECK-NEXT: | | `-ReturnStmt [[ADDR_36:0x[a-z0-9]*]] <col:15, col:22>
-// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_37:0x[a-z0-9]*]] <col:22> 'int' 3
+// CHECK:      |-FunctionDecl [[ADDR_0:0x[a-z0-9]*]] <{{.*}}, col:31> col:5 referenced picked1 'int ({{.*}})'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_1:0x[a-z0-9]*]] <col:19, col:31>
+// CHECK-NEXT: |   `-ReturnStmt [[ADDR_2:0x[a-z0-9]*]] <col:21, col:28>
+// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_3:0x[a-z0-9]*]] <col:28> 'int' 0
+// CHECK-NEXT: |-FunctionDecl [[ADDR_4:0x[a-z0-9]*]] <line:6:1, col:31> col:5 referenced picked2 'int ({{.*}})'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_5:0x[a-z0-9]*]] <col:19, col:31>
+// CHECK-NEXT: |   `-ReturnStmt [[ADDR_6:0x[a-z0-9]*]] <col:21, col:28>
+// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_7:0x[a-z0-9]*]] <col:28> 'int' 0
+// CHECK-NEXT: |-FunctionDecl [[ADDR_8:0x[a-z0-9]*]] <line:7:1, col:17> col:5 referenced picked3 'int ({{.*}})'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_9:0x[a-z0-9]*]] <line:8:1, col:17> col:5 referenced picked4 'int ({{.*}})'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_10:0x[a-z0-9]*]] <line:9:1, col:31> col:5 referenced picked5 'int ({{.*}})'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_11:0x[a-z0-9]*]] <col:19, col:31>
+// CHECK-NEXT: |   `-ReturnStmt [[ADDR_12:0x[a-z0-9]*]] <col:21, col:28>
+// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_13:0x[a-z0-9]*]] <col:28> 'int' 0
+// CHECK-NEXT: |-FunctionDecl [[ADDR_14:0x[a-z0-9]*]] <line:10:1, col:31> col:5 referenced picked6 'int ({{.*}})'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_15:0x[a-z0-9]*]] <col:19, col:31>
+// CHECK-NEXT: |   `-ReturnStmt [[ADDR_16:0x[a-z0-9]*]] <col:21, col:28>
+// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_17:0x[a-z0-9]*]] <col:28> 'int' 0
+// CHECK-NEXT: |-FunctionDecl [[ADDR_18:0x[a-z0-9]*]] <line:11:1, col:31> col:5 referenced picked7 'int ({{.*}})'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_19:0x[a-z0-9]*]] <col:19, col:31>
+// CHECK-NEXT: |   `-ReturnStmt [[ADDR_20:0x[a-z0-9]*]] <col:21, col:28>
+// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_21:0x[a-z0-9]*]] <col:28> 'int' 0
+// CHECK-NEXT: |-FunctionDecl [[ADDR_22:0x[a-z0-9]*]] <line:12:1, col:35> col:5 referenced not_picked1 'int ({{.*}})'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_23:0x[a-z0-9]*]] <col:23, col:35>
+// CHECK-NEXT: |   `-ReturnStmt [[ADDR_24:0x[a-z0-9]*]] <col:25, col:32>
+// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_25:0x[a-z0-9]*]] <col:32> 'int' 1
+// CHECK-NEXT: |-FunctionDecl [[ADDR_26:0x[a-z0-9]*]] <line:13:1, col:35> col:5 referenced not_picked2 'int ({{.*}})'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_27:0x[a-z0-9]*]] <col:23, col:35>
+// CHECK-NEXT: |   `-ReturnStmt [[ADDR_28:0x[a-z0-9]*]] <col:25, col:32>
+// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_29:0x[a-z0-9]*]] <col:32> 'int' 2
+// CHECK-NEXT: |-FunctionDecl [[ADDR_30:0x[a-z0-9]*]] <line:14:1, col:21> col:5 referenced not_picked3 'int ({{.*}})'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_31:0x[a-z0-9]*]] <line:15:1, col:21> col:5 referenced not_picked4 'int ({{.*}})'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_32:0x[a-z0-9]*]] <line:16:1, col:21> col:5 referenced not_picked5 'int ({{.*}})'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_33:0x[a-z0-9]*]] <line:17:1, col:21> col:5 referenced not_picked6 'int ({{.*}})'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_34:0x[a-z0-9]*]] <line:20:1, col:29> col:5 used base1 'int ({{.*}})'
+// CHECK-NEXT: | |-CompoundStmt [[ADDR_35:0x[a-z0-9]*]] <col:17, col:29>
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_36:0x[a-z0-9]*]] <col:19, col:26>
+// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_37:0x[a-z0-9]*]] <col:26> 'int' 3
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_38:0x[a-z0-9]*]] <line:19:1, col:107> Implicit implementation={extension(match_any)}, device={kind(cpu, gpu)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_39:0x[a-z0-9]*]] <col:29> 'int ({{.*}})' {{.*}}Function [[ADDR_0]] 'picked1' 'int ({{.*}})' non_odr_use_unevaluated
-// CHECK-NEXT: |-FunctionDecl [[ADDR_40:0x[a-z0-9]*]] <line:23:1, col:25> col:5 used base2 'int ({{.*}})'
-// CHECK-NEXT: | |-CompoundStmt [[ADDR_41:0x[a-z0-9]*]] <col:13, col:25>
-// CHECK-NEXT: | | `-ReturnStmt [[ADDR_42:0x[a-z0-9]*]] <col:15, col:22>
-// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_43:0x[a-z0-9]*]] <col:22> 'int' 4
+// CHECK-NEXT: |-FunctionDecl [[ADDR_40:0x[a-z0-9]*]] <line:23:1, col:29> col:5 used base2 'int ({{.*}})'
+// CHECK-NEXT: | |-CompoundStmt [[ADDR_41:0x[a-z0-9]*]] <col:17, col:29>
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_42:0x[a-z0-9]*]] <col:19, col:26>
+// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_43:0x[a-z0-9]*]] <col:26> 'int' 4
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_44:0x[a-z0-9]*]] <line:22:1, col:109> Implicit implementation={extension(match_none)}, device={kind(gpu, fpga)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_45:0x[a-z0-9]*]] <col:29> 'int ({{.*}})' {{.*}}Function [[ADDR_4]] 'picked2' 'int ({{.*}})' non_odr_use_unevaluated
-// CHECK-NEXT: |-FunctionDecl [[ADDR_46:0x[a-z0-9]*]] <line:26:1, col:25> col:5 used base3 'int ({{.*}})'
-// CHECK-NEXT: | |-CompoundStmt [[ADDR_47:0x[a-z0-9]*]] <col:13, col:25>
-// CHECK-NEXT: | | `-ReturnStmt [[ADDR_48:0x[a-z0-9]*]] <col:15, col:22>
-// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_49:0x[a-z0-9]*]] <col:22> 'int' 5
+// CHECK-NEXT: |-FunctionDecl [[ADDR_46:0x[a-z0-9]*]] <line:26:1, col:29> col:5 used base3 'int ({{.*}})'
+// CHECK-NEXT: | |-CompoundStmt [[ADDR_47:0x[a-z0-9]*]] <col:17, col:29>
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_48:0x[a-z0-9]*]] <col:19, col:26>
+// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_49:0x[a-z0-9]*]] <col:26> 'int' 5
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_50:0x[a-z0-9]*]] <line:25:1, col:120> Implicit implementation={vendor(pgi), extension(match_any)}, device={kind(cpu, gpu)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_51:0x[a-z0-9]*]] <col:29> 'int ({{.*}})' {{.*}}Function [[ADDR_8]] 'picked3' 'int ({{.*}})' non_odr_use_unevaluated
-// CHECK-NEXT: |-FunctionDecl [[ADDR_52:0x[a-z0-9]*]] <line:29:1, col:25> col:5 used base4 'int ({{.*}})'
-// CHECK-NEXT: | |-CompoundStmt [[ADDR_53:0x[a-z0-9]*]] <col:13, col:25>
-// CHECK-NEXT: | | `-ReturnStmt [[ADDR_54:0x[a-z0-9]*]] <col:15, col:22>
-// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_55:0x[a-z0-9]*]] <col:22> 'int' 6
+// CHECK-NEXT: |-FunctionDecl [[ADDR_52:0x[a-z0-9]*]] <line:29:1, col:29> col:5 used base4 'int ({{.*}})'
+// CHECK-NEXT: | |-CompoundStmt [[ADDR_53:0x[a-z0-9]*]] <col:17, col:29>
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_54:0x[a-z0-9]*]] <col:19, col:26>
+// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_55:0x[a-z0-9]*]] <col:26> 'int' 6
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_56:0x[a-z0-9]*]] <line:28:1, col:130> Implicit user={condition(0)}, implementation={extension(match_none)}, device={kind(gpu, fpga)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_57:0x[a-z0-9]*]] <col:29> 'int ({{.*}})' {{.*}}Function [[ADDR_9]] 'picked4' 'int ({{.*}})' non_odr_use_unevaluated
-// CHECK-NEXT: |-FunctionDecl [[ADDR_58:0x[a-z0-9]*]] <line:32:1, col:25> col:5 used base5 'int ({{.*}})'
-// CHECK-NEXT: | |-CompoundStmt [[ADDR_59:0x[a-z0-9]*]] <col:13, col:25>
-// CHECK-NEXT: | | `-ReturnStmt [[ADDR_60:0x[a-z0-9]*]] <col:15, col:22>
-// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_61:0x[a-z0-9]*]] <col:22> 'int' 7
+// CHECK-NEXT: |-FunctionDecl [[ADDR_58:0x[a-z0-9]*]] <line:32:1, col:29> col:5 used base5 'int ({{.*}})'
+// CHECK-NEXT: | |-CompoundStmt [[ADDR_59:0x[a-z0-9]*]] <col:17, col:29>
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_60:0x[a-z0-9]*]] <col:19, col:26>
+// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_61:0x[a-z0-9]*]] <col:26> 'int' 7
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_62:0x[a-z0-9]*]] <line:31:1, col:123> Implicit user={condition(1)}, implementation={extension(match_all)}, device={kind(cpu)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_63:0x[a-z0-9]*]] <col:29> 'int ({{.*}})' {{.*}}Function [[ADDR_10]] 'picked5' 'int ({{.*}})' non_odr_use_unevaluated
-// CHECK-NEXT: |-FunctionDecl [[ADDR_64:0x[a-z0-9]*]] <line:35:1, col:25> col:5 used base6 'int ({{.*}})'
-// CHECK-NEXT: | |-CompoundStmt [[ADDR_65:0x[a-z0-9]*]] <col:13, col:25>
-// CHECK-NEXT: | | `-ReturnStmt [[ADDR_66:0x[a-z0-9]*]] <col:15, col:22>
-// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_67:0x[a-z0-9]*]] <col:22> 'int' 0
+// CHECK-NEXT: |-FunctionDecl [[ADDR_64:0x[a-z0-9]*]] <line:35:1, col:29> col:5 used base6 'int ({{.*}})'
+// CHECK-NEXT: | |-CompoundStmt [[ADDR_65:0x[a-z0-9]*]] <col:17, col:29>
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_66:0x[a-z0-9]*]] <col:19, col:26>
+// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_67:0x[a-z0-9]*]] <col:26> 'int' 0
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_68:0x[a-z0-9]*]] <line:34:1, col:112> Implicit implementation={extension(match_any)}, device={kind(gpu, fpga)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_69:0x[a-z0-9]*]] <col:29> 'int ({{.*}})' {{.*}}Function [[ADDR_22]] 'not_picked1' 'int ({{.*}})' non_odr_use_unevaluated
-// CHECK-NEXT: |-FunctionDecl [[ADDR_70:0x[a-z0-9]*]] <line:38:1, col:25> col:5 used base7 'int ({{.*}})'
-// CHECK-NEXT: | |-CompoundStmt [[ADDR_71:0x[a-z0-9]*]] <col:13, col:25>
-// CHECK-NEXT: | | `-ReturnStmt [[ADDR_72:0x[a-z0-9]*]] <col:15, col:22>
-// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_73:0x[a-z0-9]*]] <col:22> 'int' 0
+// CHECK-NEXT: |-FunctionDecl [[ADDR_70:0x[a-z0-9]*]] <line:38:1, col:29> col:5 used base7 'int ({{.*}})'
+// CHECK-NEXT: | |-CompoundStmt [[ADDR_71:0x[a-z0-9]*]] <col:17, col:29>
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_72:0x[a-z0-9]*]] <col:19, col:26>
+// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_73:0x[a-z0-9]*]] <col:26> 'int' 0
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_74:0x[a-z0-9]*]] <line:37:1, col:112> Implicit implementation={extension(match_none)}, device={kind(gpu, cpu)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_75:0x[a-z0-9]*]] <col:29> 'int ({{.*}})' {{.*}}Function [[ADDR_26]] 'not_picked2' 'int ({{.*}})' non_odr_use_unevaluated
-// CHECK-NEXT: |-FunctionDecl [[ADDR_76:0x[a-z0-9]*]] <line:41:1, col:25> col:5 used base8 'int ({{.*}})'
-// CHECK-NEXT: | |-CompoundStmt [[ADDR_77:0x[a-z0-9]*]] <col:13, col:25>
-// CHECK-NEXT: | | `-ReturnStmt [[ADDR_78:0x[a-z0-9]*]] <col:15, col:22>
-// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_79:0x[a-z0-9]*]] <col:22> 'int' 0
+// CHECK-NEXT: |-FunctionDecl [[ADDR_76:0x[a-z0-9]*]] <line:41:1, col:29> col:5 used base8 'int ({{.*}})'
+// CHECK-NEXT: | |-CompoundStmt [[ADDR_77:0x[a-z0-9]*]] <col:17, col:29>
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_78:0x[a-z0-9]*]] <col:19, col:26>
+// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_79:0x[a-z0-9]*]] <col:26> 'int' 0
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_80:0x[a-z0-9]*]] <line:40:1, col:126> Implicit implementation={vendor(llvm), extension(match_any)}, device={kind(fpga, gpu)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_81:0x[a-z0-9]*]] <col:29> 'int ({{.*}})' {{.*}}Function [[ADDR_30]] 'not_picked3' 'int ({{.*}})' non_odr_use_unevaluated
-// CHECK-NEXT: |-FunctionDecl [[ADDR_82:0x[a-z0-9]*]] <line:44:1, col:25> col:5 used base9 'int ({{.*}})'
-// CHECK-NEXT: | |-CompoundStmt [[ADDR_83:0x[a-z0-9]*]] <col:13, col:25>
-// CHECK-NEXT: | | `-ReturnStmt [[ADDR_84:0x[a-z0-9]*]] <col:15, col:22>
-// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_85:0x[a-z0-9]*]] <col:22> 'int' 0
+// CHECK-NEXT: |-FunctionDecl [[ADDR_82:0x[a-z0-9]*]] <line:44:1, col:29> col:5 used base9 'int ({{.*}})'
+// CHECK-NEXT: | |-CompoundStmt [[ADDR_83:0x[a-z0-9]*]] <col:17, col:29>
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_84:0x[a-z0-9]*]] <col:19, col:26>
+// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_85:0x[a-z0-9]*]] <col:26> 'int' 0
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_86:0x[a-z0-9]*]] <line:43:1, col:134> Implicit user={condition(1)}, implementation={extension(match_none)}, device={kind(gpu, fpga)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_87:0x[a-z0-9]*]] <col:29> 'int ({{.*}})' {{.*}}Function [[ADDR_31]] 'not_picked4' 'int ({{.*}})' non_odr_use_unevaluated
-// CHECK-NEXT: |-FunctionDecl [[ADDR_88:0x[a-z0-9]*]] <line:47:1, col:26> col:5 used base10 'int ({{.*}})'
-// CHECK-NEXT: | |-CompoundStmt [[ADDR_89:0x[a-z0-9]*]] <col:14, col:26>
-// CHECK-NEXT: | | `-ReturnStmt [[ADDR_90:0x[a-z0-9]*]] <col:16, col:23>
-// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_91:0x[a-z0-9]*]] <col:23> 'int' 0
+// CHECK-NEXT: |-FunctionDecl [[ADDR_88:0x[a-z0-9]*]] <line:47:1, col:30> col:5 used base10 'int ({{.*}})'
+// CHECK-NEXT: | |-CompoundStmt [[ADDR_89:0x[a-z0-9]*]] <col:18, col:30>
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_90:0x[a-z0-9]*]] <col:20, col:27>
+// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_91:0x[a-z0-9]*]] <col:27> 'int' 0
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_92:0x[a-z0-9]*]] <line:46:1, col:132> Implicit user={condition(1)}, implementation={extension(match_all)}, device={kind(cpu, gpu)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_93:0x[a-z0-9]*]] <col:29> 'int ({{.*}})' {{.*}}Function [[ADDR_32]] 'not_picked5' 'int ({{.*}})' non_odr_use_unevaluated
-// CHECK-NEXT: |-FunctionDecl [[ADDR_94:0x[a-z0-9]*]] <line:50:1, col:26> col:5 used base11 'int ({{.*}})'
-// CHECK-NEXT: | |-CompoundStmt [[ADDR_95:0x[a-z0-9]*]] <col:14, col:26>
-// CHECK-NEXT: | | `-ReturnStmt [[ADDR_96:0x[a-z0-9]*]] <col:16, col:23>
-// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_97:0x[a-z0-9]*]] <col:23> 'int' 0
+// CHECK-NEXT: |-FunctionDecl [[ADDR_94:0x[a-z0-9]*]] <line:50:1, col:30> col:5 used base11 'int ({{.*}})'
+// CHECK-NEXT: | |-CompoundStmt [[ADDR_95:0x[a-z0-9]*]] <col:18, col:30>
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_96:0x[a-z0-9]*]] <col:20, col:27>
+// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_97:0x[a-z0-9]*]] <col:27> 'int' 0
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_98:0x[a-z0-9]*]] <line:49:1, col:86> Implicit implementation={extension(match_any)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_99:0x[a-z0-9]*]] <col:29> 'int ({{.*}})' {{.*}}Function [[ADDR_33]] 'not_picked6' 'int ({{.*}})' non_odr_use_unevaluated
-// CHECK-NEXT: |-FunctionDecl [[ADDR_100:0x[a-z0-9]*]] <line:53:1, col:26> col:5 used base12 'int ({{.*}})'
-// CHECK-NEXT: | |-CompoundStmt [[ADDR_101:0x[a-z0-9]*]] <col:14, col:26>
-// CHECK-NEXT: | | `-ReturnStmt [[ADDR_102:0x[a-z0-9]*]] <col:16, col:23>
-// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_103:0x[a-z0-9]*]] <col:23> 'int' 8
+// CHECK-NEXT: |-FunctionDecl [[ADDR_100:0x[a-z0-9]*]] <line:53:1, col:30> col:5 used base12 'int ({{.*}})'
+// CHECK-NEXT: | |-CompoundStmt [[ADDR_101:0x[a-z0-9]*]] <col:18, col:30>
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_102:0x[a-z0-9]*]] <col:20, col:27>
+// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_103:0x[a-z0-9]*]] <col:27> 'int' 8
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_104:0x[a-z0-9]*]] <line:52:1, col:82> Implicit implementation={extension(match_all)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_105:0x[a-z0-9]*]] <col:29> 'int ({{.*}})' {{.*}}Function [[ADDR_14]] 'picked6' 'int ({{.*}})' non_odr_use_unevaluated
-// CHECK-NEXT: |-FunctionDecl [[ADDR_106:0x[a-z0-9]*]] <line:56:1, col:26> col:5 used base13 'int ({{.*}})'
-// CHECK-NEXT: | |-CompoundStmt [[ADDR_107:0x[a-z0-9]*]] <col:14, col:26>
-// CHECK-NEXT: | | `-ReturnStmt [[ADDR_108:0x[a-z0-9]*]] <col:16, col:23>
-// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_109:0x[a-z0-9]*]] <col:23> 'int' 9
+// CHECK-NEXT: |-FunctionDecl [[ADDR_106:0x[a-z0-9]*]] <line:56:1, col:30> col:5 used base13 'int ({{.*}})'
+// CHECK-NEXT: | |-CompoundStmt [[ADDR_107:0x[a-z0-9]*]] <col:18, col:30>
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_108:0x[a-z0-9]*]] <col:20, col:27>
+// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_109:0x[a-z0-9]*]] <col:27> 'int' 9
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_110:0x[a-z0-9]*]] <line:55:1, col:83> Implicit implementation={extension(match_none)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_111:0x[a-z0-9]*]] <col:29> 'int ({{.*}})' {{.*}}Function [[ADDR_18]] 'picked7' 'int ({{.*}})' non_odr_use_unevaluated
-// CHECK-NEXT: |-FunctionDecl [[ADDR_112:0x[a-z0-9]*]] <line:59:1, col:17> col:5 implicit used overloaded1 'int ({{.*}})'
+// CHECK-NEXT: |-FunctionDecl [[ADDR_112:0x[a-z0-9]*]] <line:59:1, col:21> col:5 implicit used overloaded1 'int ({{.*}})'
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_113:0x[a-z0-9]*]] <<invalid sloc>> Implicit implementation={extension(match_any)}, device={kind(cpu, gpu)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_114:0x[a-z0-9]*]] <col:1> 'int ({{.*}})' {{.*}}Function [[ADDR_115:0x[a-z0-9]*]] 'overloaded1[implementation={extension(match_any)}, device={kind(cpu, gpu)}]' 'int ({{.*}})'
-// CHECK-NEXT: |-FunctionDecl [[ADDR_115]] <col:1, col:31> col:1 overloaded1[implementation={extension(match_any)}, device={kind(cpu, gpu)}] 'int ({{.*}})'
-// CHECK-NEXT: | `-CompoundStmt [[ADDR_116:0x[a-z0-9]*]] <col:19, col:31>
-// CHECK-NEXT: |   `-ReturnStmt [[ADDR_117:0x[a-z0-9]*]] <col:21, col:28>
-// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_118:0x[a-z0-9]*]] <col:28> 'int' 0
-// CHECK-NEXT: |-FunctionDecl [[ADDR_119:0x[a-z0-9]*]] <line:62:1, col:31> col:5 used overloaded2 'int ({{.*}})'
-// CHECK-NEXT: | |-CompoundStmt [[ADDR_120:0x[a-z0-9]*]] <col:19, col:31>
-// CHECK-NEXT: | | `-ReturnStmt [[ADDR_121:0x[a-z0-9]*]] <col:21, col:28>
-// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_122:0x[a-z0-9]*]] <col:28> 'int' 1
+// CHECK-NEXT: |-FunctionDecl [[ADDR_115]] <col:1, col:35> col:1 overloaded1[implementation={extension(match_any)}, device={kind(cpu, gpu)}] 'int ({{.*}})'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_116:0x[a-z0-9]*]] <col:23, col:35>
+// CHECK-NEXT: |   `-ReturnStmt [[ADDR_117:0x[a-z0-9]*]] <col:25, col:32>
+// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_118:0x[a-z0-9]*]] <col:32> 'int' 0
+// CHECK-NEXT: |-FunctionDecl [[ADDR_119:0x[a-z0-9]*]] <line:62:1, col:35> col:5 used overloaded2 'int ({{.*}})'
+// CHECK-NEXT: | |-CompoundStmt [[ADDR_120:0x[a-z0-9]*]] <col:23, col:35>
+// CHECK-NEXT: | | `-ReturnStmt [[ADDR_121:0x[a-z0-9]*]] <col:25, col:32>
+// CHECK-NEXT: | |   `-IntegerLiteral [[ADDR_122:0x[a-z0-9]*]] <col:32> 'int' 1
 // CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_123:0x[a-z0-9]*]] <<invalid sloc>> Implicit implementation={extension(match_none)}, device={kind(fpga, gpu)}
 // CHECK-NEXT: |   `-DeclRefExpr [[ADDR_124:0x[a-z0-9]*]] <line:64:1> 'int ({{.*}})' {{.*}}Function [[ADDR_125:0x[a-z0-9]*]] 'overloaded2[implementation={extension(match_none)}, device={kind(fpga, gpu)}]' 'int ({{.*}})'
-// CHECK-NEXT: |-FunctionDecl [[ADDR_125]] <col:1, col:31> col:1 overloaded2[implementation={extension(match_none)}, device={kind(fpga, gpu)}] 'int ({{.*}})'
-// CHECK-NEXT: | `-CompoundStmt [[ADDR_126:0x[a-z0-9]*]] <col:19, col:31>
-// CHECK-NEXT: |   `-ReturnStmt [[ADDR_127:0x[a-z0-9]*]] <col:21, col:28>
-// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_128:0x[a-z0-9]*]] <col:28> 'int' 0
-// CHECK-NEXT: |-FunctionDecl [[ADDR_129:0x[a-z0-9]*]] prev [[ADDR_8]] <line:72:1, col:27> col:5 picked3 'int ({{.*}})'
-// CHECK-NEXT: | `-CompoundStmt [[ADDR_130:0x[a-z0-9]*]] <col:15, col:27>
-// CHECK-NEXT: |   `-ReturnStmt [[ADDR_131:0x[a-z0-9]*]] <col:17, col:24>
-// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_132:0x[a-z0-9]*]] <col:24> 'int' 0
-// CHECK-NEXT: |-FunctionDecl [[ADDR_133:0x[a-z0-9]*]] prev [[ADDR_9]] <line:73:1, col:27> col:5 picked4 'int ({{.*}})'
-// CHECK-NEXT: | `-CompoundStmt [[ADDR_134:0x[a-z0-9]*]] <col:15, col:27>
-// CHECK-NEXT: |   `-ReturnStmt [[ADDR_135:0x[a-z0-9]*]] <col:17, col:24>
-// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_136:0x[a-z0-9]*]] <col:24> 'int' 0
-// CHECK-NEXT: |-FunctionDecl [[ADDR_137:0x[a-z0-9]*]] prev [[ADDR_30]] <line:74:1, col:32> col:5 not_picked3 'int ({{.*}})'
-// CHECK-NEXT: | `-CompoundStmt [[ADDR_138:0x[a-z0-9]*]] <col:19, col:32>
-// CHECK-NEXT: |   `-ReturnStmt [[ADDR_139:0x[a-z0-9]*]] <col:21, col:28>
-// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_140:0x[a-z0-9]*]] <col:28> 'int' 10
-// CHECK-NEXT: |-FunctionDecl [[ADDR_141:0x[a-z0-9]*]] prev [[ADDR_31]] <line:75:1, col:32> col:5 not_picked4 'int ({{.*}})'
-// CHECK-NEXT: | `-CompoundStmt [[ADDR_142:0x[a-z0-9]*]] <col:19, col:32>
-// CHECK-NEXT: |   `-ReturnStmt [[ADDR_143:0x[a-z0-9]*]] <col:21, col:28>
-// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_144:0x[a-z0-9]*]] <col:28> 'int' 11
-// CHECK-NEXT: |-FunctionDecl [[ADDR_145:0x[a-z0-9]*]] prev [[ADDR_32]] <line:76:1, col:32> col:5 not_picked5 'int ({{.*}})'
-// CHECK-NEXT: | `-CompoundStmt [[ADDR_146:0x[a-z0-9]*]] <col:19, col:32>
-// CHECK-NEXT: |   `-ReturnStmt [[ADDR_147:0x[a-z0-9]*]] <col:21, col:28>
-// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_148:0x[a-z0-9]*]] <col:28> 'int' 12
-// CHECK-NEXT: |-FunctionDecl [[ADDR_149:0x[a-z0-9]*]] prev [[ADDR_33]] <line:77:1, col:32> col:5 not_picked6 'int ({{.*}})'
-// CHECK-NEXT: | `-CompoundStmt [[ADDR_150:0x[a-z0-9]*]] <col:19, col:32>
-// CHECK-NEXT: |   `-ReturnStmt [[ADDR_151:0x[a-z0-9]*]] <col:21, col:28>
-// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_152:0x[a-z0-9]*]] <col:28> 'int' 13
+// CHECK-NEXT: |-FunctionDecl [[ADDR_125]] <col:1, col:35> col:1 overloaded2[implementation={extension(match_none)}, device={kind(fpga, gpu)}] 'int ({{.*}})'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_126:0x[a-z0-9]*]] <col:23, col:35>
+// CHECK-NEXT: |   `-ReturnStmt [[ADDR_127:0x[a-z0-9]*]] <col:25, col:32>
+// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_128:0x[a-z0-9]*]] <col:32> 'int' 0
+// CHECK-NEXT: |-FunctionDecl [[ADDR_129:0x[a-z0-9]*]] prev [[ADDR_8]] <line:72:1, col:31> col:5 picked3 'int ({{.*}})'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_130:0x[a-z0-9]*]] <col:19, col:31>
+// CHECK-NEXT: |   `-ReturnStmt [[ADDR_131:0x[a-z0-9]*]] <col:21, col:28>
+// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_132:0x[a-z0-9]*]] <col:28> 'int' 0
+// CHECK-NEXT: |-FunctionDecl [[ADDR_133:0x[a-z0-9]*]] prev [[ADDR_9]] <line:73:1, col:31> col:5 picked4 'int ({{.*}})'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_134:0x[a-z0-9]*]] <col:19, col:31>
+// CHECK-NEXT: |   `-ReturnStmt [[ADDR_135:0x[a-z0-9]*]] <col:21, col:28>
+// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_136:0x[a-z0-9]*]] <col:28> 'int' 0
+// CHECK-NEXT: |-FunctionDecl [[ADDR_137:0x[a-z0-9]*]] prev [[ADDR_30]] <line:74:1, col:36> col:5 not_picked3 'int ({{.*}})'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_138:0x[a-z0-9]*]] <col:23, col:36>
+// CHECK-NEXT: |   `-ReturnStmt [[ADDR_139:0x[a-z0-9]*]] <col:25, col:32>
+// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_140:0x[a-z0-9]*]] <col:32> 'int' 10
+// CHECK-NEXT: |-FunctionDecl [[ADDR_141:0x[a-z0-9]*]] prev [[ADDR_31]] <line:75:1, col:36> col:5 not_picked4 'int ({{.*}})'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_142:0x[a-z0-9]*]] <col:23, col:36>
+// CHECK-NEXT: |   `-ReturnStmt [[ADDR_143:0x[a-z0-9]*]] <col:25, col:32>
+// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_144:0x[a-z0-9]*]] <col:32> 'int' 11
+// CHECK-NEXT: |-FunctionDecl [[ADDR_145:0x[a-z0-9]*]] prev [[ADDR_32]] <line:76:1, col:36> col:5 not_picked5 'int ({{.*}})'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_146:0x[a-z0-9]*]] <col:23, col:36>
+// CHECK-NEXT: |   `-ReturnStmt [[ADDR_147:0x[a-z0-9]*]] <col:25, col:32>
+// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_148:0x[a-z0-9]*]] <col:32> 'int' 12
+// CHECK-NEXT: |-FunctionDecl [[ADDR_149:0x[a-z0-9]*]] prev [[ADDR_33]] <line:77:1, col:36> col:5 not_picked6 'int ({{.*}})'
+// CHECK-NEXT: | `-CompoundStmt [[ADDR_150:0x[a-z0-9]*]] <col:23, col:36>
+// CHECK-NEXT: |   `-ReturnStmt [[ADDR_151:0x[a-z0-9]*]] <col:25, col:32>
+// CHECK-NEXT: |     `-IntegerLiteral [[ADDR_152:0x[a-z0-9]*]] <col:32> 'int' 13
 // CHECK-NEXT: `-FunctionDecl [[ADDR_153:0x[a-z0-9]*]] <line:79:1, line:84:1> line:79:5 test 'int ({{.*}})'
-// CHECK-NEXT:   `-CompoundStmt [[ADDR_154:0x[a-z0-9]*]] <col:12, line:84:1>
+// CHECK-NEXT:   `-CompoundStmt [[ADDR_154:0x[a-z0-9]*]] <col:16, line:84:1>
 // CHECK-NEXT:     `-ReturnStmt [[ADDR_155:0x[a-z0-9]*]] <line:81:3, line:83:38>
 // CHECK-NEXT:       `-BinaryOperator [[ADDR_156:0x[a-z0-9]*]] <line:81:10, line:83:38> 'int' '+'
 // CHECK-NEXT:         |-BinaryOperator [[ADDR_157:0x[a-z0-9]*]] <line:81:10, line:83:22> 'int' '+'
diff --git a/clang/test/AST/ast-dump-openmp-flush.c b/clang/test/AST/ast-dump-openmp-flush.c
index d5312e436357..929f5983fb64 100644
--- a/clang/test/AST/ast-dump-openmp-flush.c
+++ b/clang/test/AST/ast-dump-openmp-flush.c
@@ -1,10 +1,10 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
-void test() {
+void test(void) {
 #pragma omp flush
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-flush.c:3:1, line:5:1> line:3:6 test 'void ()'
-// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:5:1>
+// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-flush.c:3:1, line:5:1> line:3:6 test 'void (void)'
+// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:5:1>
 // CHECK-NEXT:     `-OMPFlushDirective {{.*}} <line:4:1, col:18> openmp_standalone_directive
diff --git a/clang/test/AST/ast-dump-openmp-master.c b/clang/test/AST/ast-dump-openmp-master.c
index 5dd19fc797d5..80a2c79a4b40 100644
--- a/clang/test/AST/ast-dump-openmp-master.c
+++ b/clang/test/AST/ast-dump-openmp-master.c
@@ -1,12 +1,12 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
-void test() {
+void test(void) {
 #pragma omp master
   ;
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-master.c:3:1, line:6:1> line:3:6 test 'void ()'
-// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:6:1>
+// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-master.c:3:1, line:6:1> line:3:6 test 'void (void)'
+// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:6:1>
 // CHECK-NEXT:     `-OMPMasterDirective {{.*}} <line:4:1, col:19>
 // CHECK-NEXT:       `-NullStmt {{.*}} <line:5:3>
diff --git a/clang/test/AST/ast-dump-openmp-ordered.c b/clang/test/AST/ast-dump-openmp-ordered.c
index 928262ee467c..c4427ee0eca3 100644
--- a/clang/test/AST/ast-dump-openmp-ordered.c
+++ b/clang/test/AST/ast-dump-openmp-ordered.c
@@ -1,6 +1,6 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
-void test_one() {
+void test_one(void) {
 #pragma omp ordered
   ;
 }
@@ -19,8 +19,8 @@ void test_three(int x) {
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: |-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-ordered.c:3:1, line:6:1> line:3:6 test_one 'void ()'
-// CHECK-NEXT: | `-CompoundStmt {{.*}} <col:17, line:6:1>
+// CHECK: |-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-ordered.c:3:1, line:6:1> line:3:6 test_one 'void (void)'
+// CHECK-NEXT: | `-CompoundStmt {{.*}} <col:21, line:6:1>
 // CHECK-NEXT: |   `-OMPOrderedDirective {{.*}} <line:4:1, col:20>
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT: |       `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
diff --git a/clang/test/AST/ast-dump-openmp-parallel-sections.c b/clang/test/AST/ast-dump-openmp-parallel-sections.c
index a6e02392be96..b7706c1c58c6 100644
--- a/clang/test/AST/ast-dump-openmp-parallel-sections.c
+++ b/clang/test/AST/ast-dump-openmp-parallel-sections.c
@@ -1,20 +1,20 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
-void test_zero() {
+void test_zero(void) {
 #pragma omp parallel sections
   {}
 }
 
-void test_one() {
+void test_one(void) {
 #pragma omp parallel sections
   { ; }
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: |-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-parallel-sections.c:3:1, line:6:1> line:3:6 test_zero 'void ()'
-// CHECK-NEXT: | `-CompoundStmt {{.*}} <col:18, line:6:1>
-// CHECK-NEXT: `-FunctionDecl {{.*}} <line:8:1, line:11:1> line:8:6 test_one 'void ()'
-// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:11:1>
+// CHECK: |-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-parallel-sections.c:3:1, line:6:1> line:3:6 test_zero 'void (void)'
+// CHECK-NEXT: | `-CompoundStmt {{.*}} <col:22, line:6:1>
+// CHECK-NEXT: `-FunctionDecl {{.*}} <line:8:1, line:11:1> line:8:6 test_one 'void (void)'
+// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:21, line:11:1>
 // CHECK-NEXT:     `-OMPParallelSectionsDirective {{.*}} <line:9:1, col:30>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:10:3, col:7>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
diff --git a/clang/test/AST/ast-dump-openmp-parallel.c b/clang/test/AST/ast-dump-openmp-parallel.c
index 86ec6a9e350c..9bcd4eb06b4f 100644
--- a/clang/test/AST/ast-dump-openmp-parallel.c
+++ b/clang/test/AST/ast-dump-openmp-parallel.c
@@ -1,13 +1,13 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
-void test() {
+void test(void) {
 #pragma omp parallel
   ;
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-parallel.c:3:1, line:6:1> line:3:6 test 'void ()'
-// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:6:1>
+// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-parallel.c:3:1, line:6:1> line:3:6 test 'void (void)'
+// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:6:1>
 // CHECK-NEXT:     `-OMPParallelDirective {{.*}} <line:4:1, col:21>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
diff --git a/clang/test/AST/ast-dump-openmp-section.c b/clang/test/AST/ast-dump-openmp-section.c
index b7f04dcd707e..702bad7aa02d 100644
--- a/clang/test/AST/ast-dump-openmp-section.c
+++ b/clang/test/AST/ast-dump-openmp-section.c
@@ -1,6 +1,6 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
-void test() {
+void test(void) {
 #pragma omp sections
   {
 #pragma omp section
@@ -9,8 +9,8 @@ void test() {
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-section.c:3:1, line:9:1> line:3:6 test 'void ()'
-// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:9:1>
+// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-section.c:3:1, line:9:1> line:3:6 test 'void (void)'
+// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:9:1>
 // CHECK-NEXT:     `-OMPSectionsDirective {{.*}} <line:4:1, col:21>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3, line:8:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
diff --git a/clang/test/AST/ast-dump-openmp-sections.c b/clang/test/AST/ast-dump-openmp-sections.c
index 44616beaee2e..374325423ecd 100644
--- a/clang/test/AST/ast-dump-openmp-sections.c
+++ b/clang/test/AST/ast-dump-openmp-sections.c
@@ -1,20 +1,20 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
-void test_zero() {
+void test_zero(void) {
 #pragma omp sections
   {}
 }
 
-void test_one() {
+void test_one(void) {
 #pragma omp sections
   { ; }
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: |-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-sections.c:3:1, line:6:1> line:3:6 test_zero 'void ()'
-// CHECK-NEXT: | `-CompoundStmt {{.*}} <col:18, line:6:1>
-// CHECK-NEXT: `-FunctionDecl {{.*}} <line:8:1, line:11:1> line:8:6 test_one 'void ()'
-// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:11:1>
+// CHECK: |-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-sections.c:3:1, line:6:1> line:3:6 test_zero 'void (void)'
+// CHECK-NEXT: | `-CompoundStmt {{.*}} <col:22, line:6:1>
+// CHECK-NEXT: `-FunctionDecl {{.*}} <line:8:1, line:11:1> line:8:6 test_one 'void (void)'
+// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:21, line:11:1>
 // CHECK-NEXT:     `-OMPSectionsDirective {{.*}} <line:9:1, col:21>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:10:3, col:7>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
diff --git a/clang/test/AST/ast-dump-openmp-single.c b/clang/test/AST/ast-dump-openmp-single.c
index 250dcab0a1f5..2735c5d06100 100644
--- a/clang/test/AST/ast-dump-openmp-single.c
+++ b/clang/test/AST/ast-dump-openmp-single.c
@@ -1,13 +1,13 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
-void test() {
+void test(void) {
 #pragma omp single
   ;
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-single.c:3:1, line:6:1> line:3:6 test 'void ()'
-// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:6:1>
+// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-single.c:3:1, line:6:1> line:3:6 test 'void (void)'
+// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:6:1>
 // CHECK-NEXT:     `-OMPSingleDirective {{.*}} <line:4:1, col:19>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
diff --git a/clang/test/AST/ast-dump-openmp-target-parallel.c b/clang/test/AST/ast-dump-openmp-target-parallel.c
index 69030c40419e..3720856e7f4a 100644
--- a/clang/test/AST/ast-dump-openmp-target-parallel.c
+++ b/clang/test/AST/ast-dump-openmp-target-parallel.c
@@ -1,13 +1,13 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
-void test() {
+void test(void) {
 #pragma omp target parallel
   ;
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-target-parallel.c:3:1, line:6:1> line:3:6 test 'void ()'
-// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:6:1>
+// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-target-parallel.c:3:1, line:6:1> line:3:6 test 'void (void)'
+// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:6:1>
 // CHECK-NEXT:     `-OMPTargetParallelDirective {{.*}} <line:4:1, col:28>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
diff --git a/clang/test/AST/ast-dump-openmp-target-teams.c b/clang/test/AST/ast-dump-openmp-target-teams.c
index 2427ac232998..a510fdebd52e 100644
--- a/clang/test/AST/ast-dump-openmp-target-teams.c
+++ b/clang/test/AST/ast-dump-openmp-target-teams.c
@@ -1,13 +1,13 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
-void test() {
+void test(void) {
 #pragma omp target teams
   ;
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-target-teams.c:3:1, line:6:1> line:3:6 test 'void ()'
-// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:6:1>
+// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-target-teams.c:3:1, line:6:1> line:3:6 test 'void (void)'
+// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:6:1>
 // CHECK-NEXT:     `-OMPTargetTeamsDirective {{.*}} <line:4:1, col:25>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
diff --git a/clang/test/AST/ast-dump-openmp-target.c b/clang/test/AST/ast-dump-openmp-target.c
index 7ec113292e5e..ca33a8259c9c 100644
--- a/clang/test/AST/ast-dump-openmp-target.c
+++ b/clang/test/AST/ast-dump-openmp-target.c
@@ -1,13 +1,13 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
-void test() {
+void test(void) {
 #pragma omp target
   ;
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-target.c:3:1, line:6:1> line:3:6 test 'void ()'
-// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:6:1>
+// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-target.c:3:1, line:6:1> line:3:6 test 'void (void)'
+// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:6:1>
 // CHECK-NEXT:     `-OMPTargetDirective {{.*}} <line:4:1, col:19>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
diff --git a/clang/test/AST/ast-dump-openmp-task.c b/clang/test/AST/ast-dump-openmp-task.c
index 7594fb0a8faa..b68c0b3b7276 100644
--- a/clang/test/AST/ast-dump-openmp-task.c
+++ b/clang/test/AST/ast-dump-openmp-task.c
@@ -1,15 +1,15 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -fopenmp-version=50 -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
 typedef unsigned long omp_event_handle_t;
-void test() {
+void test(void) {
   omp_event_handle_t evt;
 #pragma omp task detach(evt)
   ;
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: `-FunctionDecl {{.*}} <line:4:1, line:8:1> line:4:6 test 'void ()'
-// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:8:1>
+// CHECK: `-FunctionDecl {{.*}} <line:4:1, line:8:1> line:4:6 test 'void (void)'
+// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:8:1>
 // CHECK:          `-OMPTaskDirective {{.*}} <line:6:1, col:29>
 // CHECK-NEXT:       |-OMPDetachClause {{.+}} <col:18, col:28>
 // CHECK-NEXT:       | `-DeclRefExpr {{.+}} <col:25> 'omp_event_handle_t':'unsigned long' lvalue Var {{.+}} 'evt' 'omp_event_handle_t':'unsigned long'
diff --git a/clang/test/AST/ast-dump-openmp-taskgroup.c b/clang/test/AST/ast-dump-openmp-taskgroup.c
index a0e6ede0a708..461d07adcfb4 100644
--- a/clang/test/AST/ast-dump-openmp-taskgroup.c
+++ b/clang/test/AST/ast-dump-openmp-taskgroup.c
@@ -1,13 +1,13 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
-void test() {
+void test(void) {
 #pragma omp taskgroup
   ;
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-taskgroup.c:3:1, line:6:1> line:3:6 test 'void ()'
-// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:6:1>
+// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-taskgroup.c:3:1, line:6:1> line:3:6 test 'void (void)'
+// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:6:1>
 // CHECK-NEXT:     `-OMPTaskgroupDirective {{.*}} <line:4:1, col:22>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:3>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
diff --git a/clang/test/AST/ast-dump-openmp-taskwait.c b/clang/test/AST/ast-dump-openmp-taskwait.c
index 61831ef79340..d20d4201c677 100644
--- a/clang/test/AST/ast-dump-openmp-taskwait.c
+++ b/clang/test/AST/ast-dump-openmp-taskwait.c
@@ -1,10 +1,10 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
-void test() {
+void test(void) {
 #pragma omp taskwait
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-taskwait.c:3:1, line:5:1> line:3:6 test 'void ()'
-// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:5:1>
+// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-taskwait.c:3:1, line:5:1> line:3:6 test 'void (void)'
+// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:5:1>
 // CHECK-NEXT:     `-OMPTaskwaitDirective {{.*}} <line:4:1, col:21> openmp_standalone_directive
diff --git a/clang/test/AST/ast-dump-openmp-taskyield.c b/clang/test/AST/ast-dump-openmp-taskyield.c
index 7465e23f701f..402542c76784 100644
--- a/clang/test/AST/ast-dump-openmp-taskyield.c
+++ b/clang/test/AST/ast-dump-openmp-taskyield.c
@@ -1,10 +1,10 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
-void test() {
+void test(void) {
 #pragma omp taskyield
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-taskyield.c:3:1, line:5:1> line:3:6 test 'void ()'
-// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:5:1>
+// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-taskyield.c:3:1, line:5:1> line:3:6 test 'void (void)'
+// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:5:1>
 // CHECK-NEXT:     `-OMPTaskyieldDirective {{.*}} <line:4:1, col:22> openmp_standalone_directive
diff --git a/clang/test/AST/ast-dump-openmp-teams.c b/clang/test/AST/ast-dump-openmp-teams.c
index 58b6bc73529a..8889af791d45 100644
--- a/clang/test/AST/ast-dump-openmp-teams.c
+++ b/clang/test/AST/ast-dump-openmp-teams.c
@@ -1,14 +1,14 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
 
-void test() {
+void test(void) {
 #pragma omp target
 #pragma omp teams
   ;
 }
 
 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-teams.c:3:1, line:7:1> line:3:6 test 'void ()'
-// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:7:1>
+// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-teams.c:3:1, line:7:1> line:3:6 test 'void (void)'
+// CHECK-NEXT:   `-CompoundStmt {{.*}} <col:17, line:7:1>
 // CHECK-NEXT:     `-OMPTargetDirective {{.*}} <line:4:1, col:19>
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:5:1, col:18>
 // CHECK-NEXT:         `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
diff --git a/clang/test/AST/ast-dump-stmt.c b/clang/test/AST/ast-dump-stmt.c
index 50b37196e6fe..12fa4b15daaf 100644
--- a/clang/test/AST/ast-dump-stmt.c
+++ b/clang/test/AST/ast-dump-stmt.c
@@ -19,7 +19,7 @@ int TestIndent = 1 + (1);
 // CHECK-NEXT: {{^}}|   `-ParenExpr{{.*0[^()]*$}}
 // CHECK-NEXT: {{^}}|     `-IntegerLiteral{{.*0[^()]*$}}
 
-void TestDeclStmt() {
+void TestDeclStmt(void) {
   int x = 0;
   int y, z;
 }
diff --git a/clang/test/AST/ast-dump-stmt.m b/clang/test/AST/ast-dump-stmt.m
index 0ce59286529c..1d349ece966f 100644
--- a/clang/test/AST/ast-dump-stmt.m
+++ b/clang/test/AST/ast-dump-stmt.m
@@ -27,7 +27,7 @@ void TestExprWithCleanup(int x) {
 @interface A
 @end
 
-void TestObjCAtCatchStmt() {
+void TestObjCAtCatchStmt(void) {
   @try {
   } @catch(A *a) {
   } @catch(...) {
diff --git a/clang/test/AST/ast-print-bool.c b/clang/test/AST/ast-print-bool.c
index 05519bcd4e54..230e4d96cf84 100644
--- a/clang/test/AST/ast-print-bool.c
+++ b/clang/test/AST/ast-print-bool.c
@@ -38,7 +38,7 @@ _Bool j;
 // diagnostic is emitted, and it used to affect the entirety of -ast-print, so
 // test only one definition of bool per compilation.
 #if DIAG
-void fn() { 1; } // expected-warning {{expression result unused}}
+void fn(void) { 1; } // expected-warning {{expression result unused}}
 #else
 // expected-no-diagnostics
 #endif
diff --git a/clang/test/AST/ast-print-enum-decl.c b/clang/test/AST/ast-print-enum-decl.c
index 0e2a8ed7d8e5..411467348fb1 100644
--- a/clang/test/AST/ast-print-enum-decl.c
+++ b/clang/test/AST/ast-print-enum-decl.c
@@ -8,13 +8,13 @@
 // RUN: echo "// expected""-warning@* 6 {{'T' is deprecated}}" >> %t.c
 // RUN: echo "// expected""-note@* 6 {{'T' has been explicitly marked deprecated here}}" >> %t.c
 //
-// RUN: %clang_cc1 -verify -ast-print %t.c \
+// RUN: %clang_cc1 -verify -ast-print -Wno-strict-prototypes %t.c \
 // RUN: | FileCheck --check-prefixes=CHECK,PRINT %s
 
 // END.
 
 // CHECK-LABEL: defFirst
-void defFirst() {
+void defFirst(void) {
   // PRINT-NEXT: enum
   // PRINT-DAG:  __attribute__((aligned(16)))
   // PRINT-DAG:  __attribute__((deprecated("")))
@@ -33,7 +33,7 @@ void defFirst() {
 }
 
 // CHECK-LABEL: defLast
-void defLast() {
+void defLast(void) {
   // PRINT-NEXT: enum __attribute__((aligned(16))) T *p0;
   enum __attribute__((aligned(16))) T *p0;
 
@@ -47,7 +47,7 @@ void defLast() {
 }
 
 // CHECK-LABEL: defMiddle
-void defMiddle() {
+void defMiddle(void) {
   // PRINT-NEXT: enum __attribute__((deprecated(""))) T *p0;
   // expected-warning@+2 {{'T' is deprecated}}
   // expected-note@+1 3 {{'T' has been explicitly marked deprecated here}}
@@ -64,7 +64,7 @@ void defMiddle() {
 }
 
 // CHECK-LABEL: declsOnly
-void declsOnly() {
+void declsOnly(void) {
   // FIXME: For some reason, attributes are ignored if they're not on the first
   // declaration and not on the definition.
 
diff --git a/clang/test/AST/ast-print-record-decl.c b/clang/test/AST/ast-print-record-decl.c
index ed2592c3a392..8553e98b8251 100644
--- a/clang/test/AST/ast-print-record-decl.c
+++ b/clang/test/AST/ast-print-record-decl.c
@@ -15,10 +15,10 @@
 //   RUN: echo "// expected""-warning@* 10 {{'T' is deprecated}}" >> %t.c
 //   RUN: echo "// expected""-note@* 10 {{'T' has been explicitly marked deprecated here}}" >> %t.c
 //
-//   RUN: %clang -target x86_64-linux -Xclang -verify -S -emit-llvm -o - %t.c \
+//   RUN: %clang -target x86_64-linux -Xclang -verify -Wno-strict-prototypes -S -emit-llvm -o - %t.c \
 //   RUN: | FileCheck --check-prefixes=CHECK,LLVM %s
 //
-//   RUN: %clang_cc1 -verify -ast-print %t.c \
+//   RUN: %clang_cc1 -verify -ast-print -Wno-strict-prototypes %t.c \
 //   RUN: | FileCheck --check-prefixes=CHECK,PRINT -DKW=struct \
 //   RUN:             -DBASES= %s
 
@@ -39,10 +39,10 @@
 //   RUN: echo "// expected""-warning@* 10 {{'T' is deprecated}}" >> %t.c
 //   RUN: echo "// expected""-note@* 10 {{'T' has been explicitly marked deprecated here}}" >> %t.c
 //
-//   RUN: %clang -target x86_64-linux -Xclang -verify -S -emit-llvm -o - %t.c \
+//   RUN: %clang -target x86_64-linux -Xclang -verify -Wno-strict-prototypes -S -emit-llvm -o - %t.c \
 //   RUN: | FileCheck --check-prefixes=CHECK,LLVM %s
 //
-//   RUN: %clang_cc1 -verify -ast-print %t.c \
+//   RUN: %clang_cc1 -verify -ast-print -Wno-strict-prototypes %t.c \
 //   RUN: | FileCheck --check-prefixes=CHECK,PRINT -DKW=union \
 //   RUN:             -DBASES= %s
 
@@ -65,10 +65,10 @@
 //   RUN: echo "// expected""-note@* 10 {{'T' has been explicitly marked deprecated here}}" >> %t.diags
 //   RUN: cat %t.diags >> %t.cpp
 //
-//   RUN: %clang -target x86_64-linux -Xclang -verify -S -emit-llvm -o - %t.cpp \
+//   RUN: %clang -target x86_64-linux -Xclang -verify -S -Wno-strict-prototypes -emit-llvm -o - %t.cpp \
 //   RUN: | FileCheck --check-prefixes=CHECK,LLVM %s
 //
-//   RUN: %clang_cc1 -verify -ast-print %t.cpp \
+//   RUN: %clang_cc1 -verify -ast-print -Wno-strict-prototypes %t.cpp \
 //   RUN: | FileCheck --check-prefixes=CHECK,PRINT,PRINT-CXX -DKW=struct \
 //   RUN:             -DBASES=' : B' %s
 //
@@ -100,7 +100,7 @@
 struct B {};
 
 // CHECK-LABEL: defFirst
-void defFirst() {
+void defFirst(void) {
   // PRINT-NEXT: [[KW]]
   // PRINT-DAG:  __attribute__((aligned(16)))
   // PRINT-DAG:  __attribute__((deprecated("")))
@@ -124,7 +124,7 @@ void defFirst() {
 }
 
 // CHECK-LABEL: defLast
-void defLast() {
+void defLast(void) {
   // PRINT-NEXT: [[KW]] __attribute__((aligned(16))) T *p0;
   KW __attribute__((aligned(16))) T *p0;
 
@@ -142,7 +142,7 @@ void defLast() {
 }
 
 // CHECK-LABEL: defMiddle
-void defMiddle() {
+void defMiddle(void) {
   // PRINT-NEXT: [[KW]] __attribute__((deprecated(""))) T *p0;
   // expected-warning@+2 {{'T' is deprecated}}
   // expected-note@+1 3 {{'T' has been explicitly marked deprecated here}}
@@ -165,7 +165,7 @@ void defMiddle() {
 }
 
 // CHECK-LABEL: defSelfRef
-void defSelfRef() {
+void defSelfRef(void) {
   // PRINT-NEXT: [[KW]] __attribute__((deprecated(""))) T *p0;
   // expected-warning@+2 {{'T' is deprecated}}
   // expected-note@+1 2 {{'T' has been explicitly marked deprecated here}}
@@ -201,7 +201,7 @@ void defSelfRef() {
 }
 
 // CHECK-LABEL: declsOnly
-void declsOnly() {
+void declsOnly(void) {
   // PRINT-NEXT: [[KW]] T *p0;
   KW T *p0;
 
@@ -224,7 +224,7 @@ void declsOnly() {
 // of a tag declaration.  The base class list is checked above.
 
 // CHECK-LABEL: inMembers
-void inMembers() {
+void inMembers(void) {
   // PRINT-NEXT: [[KW]] T1 {
   // PRINT-NEXT:   int i;
   // PRINT-NEXT: };
@@ -236,7 +236,7 @@ void inMembers() {
 }
 
 // CHECK-LABEL: inInit
-void inInit() {
+void inInit(void) {
   // PRINT-NEXT: [[KW]] T1 {
   // PRINT-NEXT:   int i;
   // PRINT-NEXT: };
diff --git a/clang/test/AST/attr-target-ast.c b/clang/test/AST/attr-target-ast.c
index 6e8497ea9c8d..130a8328b854 100644
--- a/clang/test/AST/attr-target-ast.c
+++ b/clang/test/AST/attr-target-ast.c
@@ -1,5 +1,5 @@
 // RUN: %clang_cc1 -triple x86_64-linux-gnu -ast-dump %s | FileCheck %s
 
-int __attribute__((target("arch=hiss,arch=woof"))) pine_tree() { return 4; }
+int __attribute__((target("arch=hiss,arch=woof"))) pine_tree(void) { return 4; }
 // CHECK-NOT: arch=hiss
 // CHECK-NOT: arch=woof
diff --git a/clang/test/AST/finally-msvc.m b/clang/test/AST/finally-msvc.m
index 5db08a7f7100..902b156bc6c8 100644
--- a/clang/test/AST/finally-msvc.m
+++ b/clang/test/AST/finally-msvc.m
@@ -1,7 +1,7 @@
 // RUN: %clang_cc1 -triple i686--windows-msvc -fexceptions -fobjc-exceptions -ast-dump %s 2>&1 | FileCheck %s
 // RUN: %clang_cc1 -triple x86_64--windows-msvc -fexceptions -fobjc-exceptions -ast-dump %s 2>&1 | FileCheck %s
 
-void f() {
+void f(void) {
   @try {
   } @finally {
   }
diff --git a/clang/test/AST/implicit-cast-dump.c b/clang/test/AST/implicit-cast-dump.c
index 609ad2f6d4d8..7ffddfbde0d7 100644
--- a/clang/test/AST/implicit-cast-dump.c
+++ b/clang/test/AST/implicit-cast-dump.c
@@ -11,8 +11,8 @@ void foo1(void*);
 void foo2(void* const);
 
 
-void bar() {
-  // CHECK:  FunctionDecl {{.*}} <line:{{.*}}, line:{{.*}}> line:{{.*}} bar 'void ()'
+void bar(void) {
+  // CHECK:  FunctionDecl {{.*}} <line:{{.*}}, line:{{.*}}> line:{{.*}} bar 'void (void)'
 
   foo1(0);
   // CHECK: ImplicitCastExpr {{.*}} <col:{{.*}}> 'void *' <NullToPointer>
diff --git a/clang/test/AST/nrvo.c b/clang/test/AST/nrvo.c
index 4f50d6a1e384..a3e12759ad0d 100644
--- a/clang/test/AST/nrvo.c
+++ b/clang/test/AST/nrvo.c
@@ -2,9 +2,9 @@
 
 struct A {};
 
-struct A f1() {
-  // CHECK:      FunctionDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:1, line:{{[^:]*}}:1> line:[[@LINE-1]]:10 f1 'struct A ()'
-  // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:15, line:{{[^:]*}}:1>
+struct A f1(void) {
+  // CHECK:      FunctionDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:1, line:{{[^:]*}}:1> line:[[@LINE-1]]:10 f1 'struct A (void)'
+  // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:19, line:{{[^:]*}}:1>
   struct A a;
   // CHECK-NEXT: DeclStmt 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:13>
   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:3, col:12> col:12 used a 'struct A':'struct A' nrvo
@@ -14,7 +14,7 @@ struct A f1() {
   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:10> 'struct A':'struct A' lvalue Var 0x{{[^ ]*}} 'a' 'struct A':'struct A'
 }
 
-void f2() {
+void f2(void) {
   (void)^{
     // CHECK:      BlockDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:9, line:{{[^:]*}}:3> line:[[@LINE-1]]:9
     // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:10, line:{{[^:]*}}:3>
diff --git a/clang/test/AST/pragma-attribute-objc-subject-match-rules.m b/clang/test/AST/pragma-attribute-objc-subject-match-rules.m
index 09ab5e1f33a0..f2a8bdde6d0c 100644
--- a/clang/test/AST/pragma-attribute-objc-subject-match-rules.m
+++ b/clang/test/AST/pragma-attribute-objc-subject-match-rules.m
@@ -92,11 +92,11 @@
 
 @end
 
-void (^testBlockVar)();
+void (^testBlockVar)(void);
 // CHECK-BLOCK: VarDecl{{.*}} testBlockVar
 // CHECK-BLOCK-NOT: AnnotateAttr{{.*}} "test"
 
-void testBlock() {
+void testBlock(void) {
   (void)(^ { });
 }
 // CHECK-BLOCK-LABEL: BlockDecl
diff --git a/clang/test/ASTMerge/codegen-body/Inputs/body1.c b/clang/test/ASTMerge/codegen-body/Inputs/body1.c
index d4d1e4b93781..194e85273f91 100644
--- a/clang/test/ASTMerge/codegen-body/Inputs/body1.c
+++ b/clang/test/ASTMerge/codegen-body/Inputs/body1.c
@@ -1,6 +1,6 @@
-int f();
+int f(void);
 
-int main()
+int main(void)
 {
   return f();
 }
diff --git a/clang/test/ASTMerge/codegen-body/Inputs/body2.c b/clang/test/ASTMerge/codegen-body/Inputs/body2.c
index 73cb1edf9917..534408a5bd8f 100644
--- a/clang/test/ASTMerge/codegen-body/Inputs/body2.c
+++ b/clang/test/ASTMerge/codegen-body/Inputs/body2.c
@@ -1,4 +1,4 @@
-__inline__ __attribute__ ((always_inline)) int f()
+__inline__ __attribute__ ((always_inline)) int f(void)
 {
   return 2;
 }
diff --git a/clang/test/ASTMerge/generic-selection-expr/Inputs/generic.c b/clang/test/ASTMerge/generic-selection-expr/Inputs/generic.c
index 41b8d1705811..85a0b57e8929 100644
--- a/clang/test/ASTMerge/generic-selection-expr/Inputs/generic.c
+++ b/clang/test/ASTMerge/generic-selection-expr/Inputs/generic.c
@@ -1,4 +1,4 @@
-void f() {
+void f(void) {
   int x;
   float y;
   _Static_assert(_Generic(x, float : 0, int : 1), "Incorrect semantics of _Generic");
diff --git a/clang/test/ASTMerge/macro/Inputs/macro1.m b/clang/test/ASTMerge/macro/Inputs/macro1.m
index 2612613bd0be..e142ce5c7304 100644
--- a/clang/test/ASTMerge/macro/Inputs/macro1.m
+++ b/clang/test/ASTMerge/macro/Inputs/macro1.m
@@ -1,5 +1,5 @@
 @import macro1;
 
-void foo() {
+void foo(void) {
   maybeNull(0, 0);
 }
diff --git a/clang/test/ASTMerge/macro/Inputs/macro2.m b/clang/test/ASTMerge/macro/Inputs/macro2.m
index b5b155a95b52..a1a9ba2fda89 100644
--- a/clang/test/ASTMerge/macro/Inputs/macro2.m
+++ b/clang/test/ASTMerge/macro/Inputs/macro2.m
@@ -1,5 +1,5 @@
-void foo();
+void foo(void);
 
-void bar() {
+void bar(void) {
   foo();
 }
diff --git a/clang/test/CodeCompletion/tag.c b/clang/test/CodeCompletion/tag.c
index 4a34c4c77222..f48ef919f027 100644
--- a/clang/test/CodeCompletion/tag.c
+++ b/clang/test/CodeCompletion/tag.c
@@ -2,9 +2,9 @@ enum X { x };
 enum Y { y };
 struct Z { };
 
-void X();
+void X(void);
 
-void test() {
+void test(void) {
   enum X { x };
   enum 
   // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:9:8 %s -o - | FileCheck -check-prefix=CHECK-CC1 %s
diff --git a/clang/test/Coverage/html-multifile-diagnostics.c b/clang/test/Coverage/html-multifile-diagnostics.c
index 39cddc99ba6f..8389dfa8ce5a 100644
--- a/clang/test/Coverage/html-multifile-diagnostics.c
+++ b/clang/test/Coverage/html-multifile-diagnostics.c
@@ -18,6 +18,6 @@
 
 #include "html-multifile-diagnostics.h"
 
-void f0() {
+void f0(void) {
   f1((int*)0);
 }
diff --git a/clang/test/CoverageMapping/abspath.cpp b/clang/test/CoverageMapping/abspath.cpp
index 4fa8eb9467f3..c9705a64c335 100644
--- a/clang/test/CoverageMapping/abspath.cpp
+++ b/clang/test/CoverageMapping/abspath.cpp
@@ -5,7 +5,7 @@
 // RMDOTS: "
 
 // RUN: mkdir -p %t/test && cd %t/test
-// RUN: echo "void f1() {}" > f1.c
+// RUN: echo "void f1(void) {}" > f1.c
 // RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -mllvm -enable-name-compression=false -emit-llvm -main-file-name abspath.cpp %t/test/f1.c -o - | FileCheck -check-prefix=ABSPATH %s
 
 // RELPATH: @__llvm_coverage_mapping = {{.*}}"\02
@@ -16,4 +16,4 @@
 // ABSPATH: {{[/\\].*(/|\\\\)test(/|\\\\)f1}}.c
 // ABSPATH: "
 
-void f1() {}
+void f1(void) {}
diff --git a/clang/test/CoverageMapping/block-storage-starts-region.m b/clang/test/CoverageMapping/block-storage-starts-region.m
index 47696c42d55c..f9ee673576ad 100644
--- a/clang/test/CoverageMapping/block-storage-starts-region.m
+++ b/clang/test/CoverageMapping/block-storage-starts-region.m
@@ -4,9 +4,9 @@
 @end
 
 // CHECK-LABEL: doSomething:
-void doSomething() { // CHECK: File 0, [[@LINE]]:20 -> {{[0-9:]+}} = #0
+void doSomething(void) { // CHECK: File 0, [[@LINE]]:24 -> {{[0-9:]+}} = #0
   return;
   __block Foo *f; // CHECK: File 0, [[@LINE]]:3 -> {{[0-9:]+}} = 0
 }
 
-int main() {}
+int main(void) {}
diff --git a/clang/test/CoverageMapping/break.c b/clang/test/CoverageMapping/break.c
index d7a0bc38cce7..17083493a340 100644
--- a/clang/test/CoverageMapping/break.c
+++ b/clang/test/CoverageMapping/break.c
@@ -1,6 +1,6 @@
 // RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name break.c %s | FileCheck %s
 
-int main() {         // CHECK: File 0, [[@LINE]]:12 -> {{[0-9]+}}:2 = #0
+int main(void) {     // CHECK: File 0, [[@LINE]]:16 -> {{[0-9]+}}:2 = #0
   int cnt = 0;       // CHECK-NEXT: File 0, [[@LINE+1]]:9 -> [[@LINE+1]]:18 = #0
   while(cnt < 100) { // CHECK: File 0, [[@LINE]]:20 -> [[@LINE+3]]:4 = #1
     break;           // CHECK-NEXT: Gap,File 0, [[@LINE]]:11 -> [[@LINE+1]]:5 = 0
diff --git a/clang/test/CoverageMapping/builtinmacro.c b/clang/test/CoverageMapping/builtinmacro.c
index 482b74158bb3..abcdc191523a 100644
--- a/clang/test/CoverageMapping/builtinmacro.c
+++ b/clang/test/CoverageMapping/builtinmacro.c
@@ -8,7 +8,7 @@ const char *filename (const char *name) { // CHECK-NEXT: File 0, [[@LINE]]:41 ->
   return this_file;
 }
 
-int main() { // CHECK-NEXT: main
+int main(void) { // CHECK-NEXT: main
   filename(__FILE__ "test.c");
   return 0;
 }
diff --git a/clang/test/CoverageMapping/casts.c b/clang/test/CoverageMapping/casts.c
index a289cb88dd8f..0f7621041c64 100644
--- a/clang/test/CoverageMapping/casts.c
+++ b/clang/test/CoverageMapping/casts.c
@@ -1,6 +1,6 @@
 // RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name casts.c %s | FileCheck %s
 
-int main() {                                                   // CHECK: File 0, [[@LINE]]:12 -> [[@LINE+4]]:2 = #0
+int main(void) {                                               // CHECK: File 0, [[@LINE]]:16 -> [[@LINE+4]]:2 = #0
                                                                // CHECK: File 0, [[@LINE+1]]:41 -> [[@LINE+1]]:54 = #1
   int window_size = (sizeof(int) <= 2 ? (unsigned)512 : 1024); // CHECK-NEXT: File 0, [[@LINE]]:57 -> [[@LINE]]:61 = (#0 - #1)
   return 0;
diff --git a/clang/test/CoverageMapping/comment-in-macro.c b/clang/test/CoverageMapping/comment-in-macro.c
index 8e77050e8bbd..1afde46f1e4a 100644
--- a/clang/test/CoverageMapping/comment-in-macro.c
+++ b/clang/test/CoverageMapping/comment-in-macro.c
@@ -3,9 +3,9 @@
 #define x1 "" // ...
 #define x2 return 0
 // CHECK: main
-int main() { // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+3]]:2 = #0
-  x1;        // CHECK-NEXT: Expansion,File 0, [[@LINE]]:3 -> [[@LINE]]:5 = #0
-  x2;        // CHECK-NEXT: Expansion,File 0, [[@LINE]]:3 -> [[@LINE]]:5 = #0
+int main(void) { // CHECK-NEXT: File 0, [[@LINE]]:16 -> [[@LINE+3]]:2 = #0
+  x1;            // CHECK-NEXT: Expansion,File 0, [[@LINE]]:3 -> [[@LINE]]:5 = #0
+  x2;            // CHECK-NEXT: Expansion,File 0, [[@LINE]]:3 -> [[@LINE]]:5 = #0
 }
 // CHECK-NEXT: File 1, 3:12 -> 3:14 = #0
 // CHECK-NEXT: File 2, 4:12 -> 4:20 = #0
diff --git a/clang/test/CoverageMapping/continue.c b/clang/test/CoverageMapping/continue.c
index d39370ed3ee3..529716b1fa92 100644
--- a/clang/test/CoverageMapping/continue.c
+++ b/clang/test/CoverageMapping/continue.c
@@ -1,6 +1,6 @@
 // RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name continue.c %s | FileCheck %s
 
-int main() {                    // CHECK: File 0, [[@LINE]]:12 -> [[@LINE+23]]:2 = #0
+int main(void) {                // CHECK: File 0, [[@LINE]]:16 -> [[@LINE+23]]:2 = #0
   int j = 0;                    // CHECK-NEXT: File 0, [[@LINE+3]]:18 -> [[@LINE+3]]:24 = (#0 + #1)
                                 // CHECK-NEXT: Branch,File 0, [[@LINE+2]]:18 -> [[@LINE+2]]:24 = #1, #0
                                 // CHECK-NEXT: File 0, [[@LINE+1]]:26 -> [[@LINE+1]]:29 = #1
diff --git a/clang/test/CoverageMapping/decl.c b/clang/test/CoverageMapping/decl.c
index 73433eba574b..31f79a2500a3 100644
--- a/clang/test/CoverageMapping/decl.c
+++ b/clang/test/CoverageMapping/decl.c
@@ -6,10 +6,10 @@
 
 // FOO: foo:
 // FOO-NOT: foo:
-inline int foo() { return 0; }
-extern inline int foo();
+inline int foo(void) { return 0; }
+extern inline int foo(void);
 
 // BAR: bar:
 // BAR-NOT: bar:
-int bar() { return 0; }
-extern int bar();
+int bar(void) { return 0; }
+extern int bar(void);
diff --git a/clang/test/CoverageMapping/implicit-def-in-macro.m b/clang/test/CoverageMapping/implicit-def-in-macro.m
index feeffc520f6c..4f8d57c37823 100644
--- a/clang/test/CoverageMapping/implicit-def-in-macro.m
+++ b/clang/test/CoverageMapping/implicit-def-in-macro.m
@@ -13,4 +13,4 @@
 }
 @end
 
-int main() {}
+int main(void) {}
diff --git a/clang/test/CoverageMapping/include-macros.c b/clang/test/CoverageMapping/include-macros.c
index 3cd0b49c475f..8adb34bd2287 100644
--- a/clang/test/CoverageMapping/include-macros.c
+++ b/clang/test/CoverageMapping/include-macros.c
@@ -2,12 +2,12 @@
 
 #include "Inputs/macros.h"
 
-void f1() {
+void f1(void) {
   M2("a", "b");
 }
 
 // CHECK-LABEL: f1:
-// CHECK-NEXT:   File 0, 5:11 -> 7:2 = #0
+// CHECK-NEXT:   File 0, 5:15 -> 7:2 = #0
 // CHECK-NEXT:   Expansion,File 0, 6:3 -> 6:5 = #0 (Expanded file = 1)
 // CHECK-NEXT:   File 1, 13:20 -> 13:50 = #0
 // CHECK-NEXT:   Expansion,File 1, 13:20 -> 13:22 = #0 (Expanded file = 2)
diff --git a/clang/test/CoverageMapping/ir.c b/clang/test/CoverageMapping/ir.c
index da36312fe8bd..7dd23943f701 100644
--- a/clang/test/CoverageMapping/ir.c
+++ b/clang/test/CoverageMapping/ir.c
@@ -2,7 +2,7 @@
 // RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -triple x86_64-apple-macosx10.9 -main-file-name ir.c %s -o - -emit-llvm -fprofile-instrument=clang -fcoverage-mapping -mllvm -enable-name-compression=false | FileCheck %s -check-prefixes=COMMON,DARWIN
 // RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -triple x86_64--windows-msvc -main-file-name ir.c %s -o - -emit-llvm -fprofile-instrument=clang -fcoverage-mapping -mllvm -enable-name-compression=false | FileCheck %s -check-prefixes=COMMON,WINDOWS
 
-static inline void unused() {}
+static inline void unused(void) {}
 
 void foo(void) {}
 
diff --git a/clang/test/CoverageMapping/loopmacro.c b/clang/test/CoverageMapping/loopmacro.c
index 8a57eb66bcd4..1fbb1139abf0 100644
--- a/clang/test/CoverageMapping/loopmacro.c
+++ b/clang/test/CoverageMapping/loopmacro.c
@@ -1,7 +1,7 @@
 // RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name loopmacro.c %s | FileCheck %s
 
 // CHECK: main
-// CHECK-NEXT: File 0, {{[0-9]+}}:12 -> {{[0-9]+}}:2 = #0
+// CHECK-NEXT: File 0, {{[0-9]+}}:16 -> {{[0-9]+}}:2 = #0
 // CHECK-NEXT: File 0, {{[0-9]+}}:6 -> {{[0-9]+}}:4 = (#0 + #1)
 // CHECK-NEXT: Expansion,File 0, {{[0-9]+}}:7 -> {{[0-9]+}}:20 = (#0 + #1)
 // CHECK-NEXT: File 0, {{[0-9]+}}:12 -> {{[0-9]+}}:30 = (#0 + #1)
@@ -33,7 +33,7 @@
 // CHECK-NEXT: File 8, [[@LINE+1]]:20 -> [[@LINE+1]]:21 = (#0 + #1)
 #define MIN_MATCH  3
 
-int main() {
+int main(void) {
   int strstart = 0;
   int hash_head = 2;
   int prev_length = 5;
diff --git a/clang/test/CoverageMapping/macroception.c b/clang/test/CoverageMapping/macroception.c
index d38150c2ca92..6d4b3ed427f7 100644
--- a/clang/test/CoverageMapping/macroception.c
+++ b/clang/test/CoverageMapping/macroception.c
@@ -6,28 +6,28 @@
 #define M11 M22
 
 // CHECK-LABEL: main:
-// CHECK-NEXT: Expansion,File 0, [[@LINE+2]]:12 -> [[@LINE+2]]:14 = #0
-// CHECK-NEXT: File 0, [[@LINE+1]]:14 -> [[@LINE+3]]:2 = #0
-int main() M1
+// CHECK-NEXT: Expansion,File 0, [[@LINE+2]]:16 -> [[@LINE+2]]:18 = #0
+// CHECK-NEXT: File 0, [[@LINE+1]]:18 -> [[@LINE+3]]:2 = #0
+int main(void) M1
   return 0;
 }
 // CHECK-NEXT: Expansion,File 1, 4:12 -> 4:14 = #0
 // CHECK-NEXT: File 2, 3:12 -> 3:13 = #0
 
 // CHECK-LABEL: func2:
-// CHECK-NEXT: File 0, [[@LINE+2]]:14 -> [[@LINE+4]]:4 = #0
+// CHECK-NEXT: File 0, [[@LINE+2]]:18 -> [[@LINE+4]]:4 = #0
 // CHECK-NEXT: Expansion,File 0, [[@LINE+3]]:1 -> [[@LINE+3]]:4 = #0
-void func2() {
+void func2(void) {
   int x = 0;
 M11
 // CHECK-NEXT: Expansion,File 1, 6:13 -> 6:16 = #0
 // CHECK-NEXT: File 2, 5:13 -> 5:14 = #0
 
 // CHECK-LABEL: func3:
-// CHECK-NEXT: Expansion,File 0, [[@LINE+3]]:14 -> [[@LINE+3]]:16 = #0
-// CHECK-NEXT: File 0, [[@LINE+2]]:16 -> [[@LINE+4]]:4 = #0
+// CHECK-NEXT: Expansion,File 0, [[@LINE+3]]:18 -> [[@LINE+3]]:20 = #0
+// CHECK-NEXT: File 0, [[@LINE+2]]:20 -> [[@LINE+4]]:4 = #0
 // CHECK-NEXT: Expansion,File 0, [[@LINE+3]]:1 -> [[@LINE+3]]:4 = #0
-void func3() M1
+void func3(void) M1
   int x = 0;
 M11
 // CHECK-NEXT: Expansion,File 1, 4:12 -> 4:14 = #0
@@ -36,10 +36,10 @@ M11
 // CHECK-NEXT: File 4, 5:13 -> 5:14 = #0
 
 // CHECK-LABEL: func4:
-// CHECK-NEXT: Expansion,File 0, [[@LINE+3]]:14 -> [[@LINE+3]]:16 = #0
-// CHECK-NEXT: File 0, [[@LINE+2]]:16 -> [[@LINE+2]]:20 = #0
-// CHECK-NEXT: Expansion,File 0, [[@LINE+1]]:17 -> [[@LINE+1]]:20 = #0
-void func4() M1 M11
+// CHECK-NEXT: Expansion,File 0, [[@LINE+3]]:18 -> [[@LINE+3]]:20 = #0
+// CHECK-NEXT: File 0, [[@LINE+2]]:20 -> [[@LINE+2]]:24 = #0
+// CHECK-NEXT: Expansion,File 0, [[@LINE+1]]:21 -> [[@LINE+1]]:24 = #0
+void func4(void) M1 M11
 // CHECK-NEXT: Expansion,File 1, 4:12 -> 4:14 = #0
 // CHECK-NEXT: Expansion,File 2, 6:13 -> 6:16 = #0
 // CHECK-NEXT: File 3, 3:12 -> 3:13 = #0
diff --git a/clang/test/CoverageMapping/macroparams.c b/clang/test/CoverageMapping/macroparams.c
index d0480f6da5cc..2f60cffbfdb7 100644
--- a/clang/test/CoverageMapping/macroparams.c
+++ b/clang/test/CoverageMapping/macroparams.c
@@ -1,7 +1,7 @@
 // RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name macroparams.c %s | FileCheck %s
 
 // CHECK: main
-// CHECK-NEXT: File 0, {{[0-9]+}}:12 -> {{[0-9]+}}:2 = #0
+// CHECK-NEXT: File 0, {{[0-9]+}}:16 -> {{[0-9]+}}:2 = #0
 // CHECK-NEXT: Expansion,File 0, {{[0-9]+}}:3 -> {{[0-9]+}}:8 = #0
 
 // CHECK-NEXT: File 1, [[@LINE+2]]:18 -> [[@LINE+2]]:27 = #0
@@ -10,7 +10,7 @@
 // CHECK-NEXT: File 2, [[@LINE+1]]:20 -> [[@LINE+1]]:28 = #0
 #define MACRO2(X2) (X2 + 2)
 
-int main() {
+int main(void) {
   int x = 0;
   MACRO(x);
   return 0;
diff --git a/clang/test/CoverageMapping/macroparams2.c b/clang/test/CoverageMapping/macroparams2.c
index 52517323742b..7873b6ac12a9 100644
--- a/clang/test/CoverageMapping/macroparams2.c
+++ b/clang/test/CoverageMapping/macroparams2.c
@@ -6,8 +6,8 @@ struct S {
   int i, j;
 };
 
-// CHECK: File 0, [[@LINE+1]]:12 -> [[@LINE+11]]:2 = #0
-int main() {
+// CHECK: File 0, [[@LINE+1]]:16 -> [[@LINE+11]]:2 = #0
+int main(void) {
   struct S arr[32] = { 0 };
   int n = 0;
   // CHECK-NEXT: Expansion,File 0, [[@LINE+3]]:7 -> [[@LINE+3]]:12 = #0
diff --git a/clang/test/CoverageMapping/macros.c b/clang/test/CoverageMapping/macros.c
index b35444d78f3a..6bd3be434139 100644
--- a/clang/test/CoverageMapping/macros.c
+++ b/clang/test/CoverageMapping/macros.c
@@ -6,10 +6,10 @@
 #define MACRO_3 MACRO_2
 #define GOTO goto
 
-void bar() {}
+void bar(void) {}
 
 // CHECK: func
-void func() {  // CHECK-NEXT: File 0, [[@LINE]]:13 -> [[@LINE+5]]:2 = #0
+void func(void) {  // CHECK-NEXT: File 0, [[@LINE]]:17 -> [[@LINE+5]]:2 = #0
   int i = 0;
   // CHECK-NEXT: Expansion,File 0, [[@LINE+1]]:3 -> [[@LINE+1]]:8 = #0
   MACRO;       // CHECK-NEXT: File 0, [[@LINE]]:8 -> [[@LINE+2]]:2 = 0
@@ -19,7 +19,7 @@ void func() {  // CHECK-NEXT: File 0, [[@LINE]]:13 -> [[@LINE+5]]:2 = #0
 // CHECK-NEXT: File 1, 3:23 -> 3:28 = 0
 
 // CHECK-NEXT: func2
-void func2() { // CHECK-NEXT: File 0, [[@LINE]]:14 -> [[@LINE+5]]:2 = #0
+void func2(void) { // CHECK-NEXT: File 0, [[@LINE]]:18 -> [[@LINE+5]]:2 = #0
   int i = 0;
   // CHECK-NEXT: Expansion,File 0, [[@LINE+1]]:3 -> [[@LINE+1]]:10 = #0
   MACRO_1;     // CHECK-NEXT: File 0, [[@LINE]]:10 -> [[@LINE+2]]:2 = 0
@@ -30,7 +30,7 @@ void func2() { // CHECK-NEXT: File 0, [[@LINE]]:14 -> [[@LINE+5]]:2 = #0
 // CHECK-NEXT: File 2, 4:17 -> 4:22 = 0
 
 // CHECK-NEXT: func3
-void func3() { // CHECK-NEXT: File 0, [[@LINE]]:14 -> [[@LINE+3]]:2 = #0
+void func3(void) { // CHECK-NEXT: File 0, [[@LINE]]:18 -> [[@LINE+3]]:2 = #0
   MACRO_2; // CHECK-NEXT: Expansion,File 0, [[@LINE]]:3 -> [[@LINE]]:10 = #0
   MACRO_2; // CHECK-NEXT: Expansion,File 0, [[@LINE]]:3 -> [[@LINE]]:10 = #0
 }
@@ -38,7 +38,7 @@ void func3() { // CHECK-NEXT: File 0, [[@LINE]]:14 -> [[@LINE+3]]:2 = #0
 // CHECK-NEXT: File 2, 4:17 -> 4:22 = #0
 
 // CHECK-NEXT: func4
-void func4() { // CHECK-NEXT: File 0, [[@LINE]]:14 -> [[@LINE+8]]:2 = #0
+void func4(void) { // CHECK-NEXT: File 0, [[@LINE]]:18 -> [[@LINE+8]]:2 = #0
   int i = 0;
   while (i++ < 10) // CHECK-NEXT: File 0, [[@LINE]]:10 -> [[@LINE]]:18 = (#0 + #1)
     if (i < 5) // CHECK: File 0, [[@LINE]]:5 -> [[@LINE+4]]:14 = #1
@@ -51,7 +51,7 @@ void func4() { // CHECK-NEXT: File 0, [[@LINE]]:14 -> [[@LINE+8]]:2 = #0
 // CHECK-NOT: File 1
 
 // CHECK-NEXT: func5
-void func5() { // CHECK-NEXT: File 0, [[@LINE]]:14 -> [[@LINE+6]]:2 = #0
+void func5(void) { // CHECK-NEXT: File 0, [[@LINE]]:18 -> [[@LINE+6]]:2 = #0
   int i = 0;
   if (i > 5) // CHECK-NEXT: File 0, [[@LINE]]:7 -> [[@LINE]]:12 = #0
              // CHECK-NEXT: Branch,File 0, [[@LINE-1]]:7 -> [[@LINE-1]]:12 = #1, (#0 - #1)
@@ -76,16 +76,16 @@ begin:                       // CHECK-NEXT: File 0, [[@LINE]]:1 -> [[@LINE+5]]:2
 // CHECK-NEXT: func7
 int k, l;
 #define m(e) e##e
-void func7() { // CHECK-NEXT: File 0, [[@LINE]]:14 -> [[@LINE+6]]:2 = #0
-  int kk,ll;   // CHECK-NEXT: File 0, [[@LINE+1]]:7 -> [[@LINE+1]]:8 = #0
-  if (k)       // CHECK-NEXT: Branch,File 0, [[@LINE]]:7 -> [[@LINE]]:8 = #1
-    m(k);      // CHECK-NEXT: Gap,File 0, [[@LINE-1]]:9 -> [[@LINE]]:5 = #1
-  else         // CHECK-NEXT: Expansion,File 0, [[@LINE-1]]:5 -> [[@LINE-1]]:6 = #0
-    l = m(l);  // CHECK-NEXT: Gap,File 0, [[@LINE-2]]:7 -> [[@LINE]]:5 = (#0 - #1)
-}              // CHECK-NEXT: File 0, [[@LINE-1]]:5 -> [[@LINE-1]]:10 = (#0 - #1)
-               // CHECK-NEXT: Expansion,File 0, [[@LINE-2]]:9 -> [[@LINE-2]]:10 = (#0 - #1)
-               // CHECK-NEXT: File 1, [[@LINE-9]]:14 -> [[@LINE-9]]:18 = #0
-               // CHECK-NEXT: File 2, [[@LINE-10]]:14 -> [[@LINE-10]]:15 = (#0 - #1)
+void func7(void) { // CHECK-NEXT: File 0, [[@LINE]]:18 -> [[@LINE+6]]:2 = #0
+  int kk,ll;       // CHECK-NEXT: File 0, [[@LINE+1]]:7 -> [[@LINE+1]]:8 = #0
+  if (k)           // CHECK-NEXT: Branch,File 0, [[@LINE]]:7 -> [[@LINE]]:8 = #1
+    m(k);          // CHECK-NEXT: Gap,File 0, [[@LINE-1]]:9 -> [[@LINE]]:5 = #1
+  else             // CHECK-NEXT: Expansion,File 0, [[@LINE-1]]:5 -> [[@LINE-1]]:6 = #0
+    l = m(l);      // CHECK-NEXT: Gap,File 0, [[@LINE-2]]:7 -> [[@LINE]]:5 = (#0 - #1)
+}                  // CHECK-NEXT: File 0, [[@LINE-1]]:5 -> [[@LINE-1]]:10 = (#0 - #1)
+                   // CHECK-NEXT: Expansion,File 0, [[@LINE-2]]:9 -> [[@LINE-2]]:10 = (#0 - #1)
+                   // CHECK-NEXT: File 1, [[@LINE-9]]:14 -> [[@LINE-9]]:18 = #0
+                   // CHECK-NEXT: File 2, [[@LINE-10]]:14 -> [[@LINE-10]]:15 = (#0 - #1)
 
 int main(int argc, const char *argv[]) {
   func();
diff --git a/clang/test/CoverageMapping/preprocessor.c b/clang/test/CoverageMapping/preprocessor.c
index 1bff72699ca3..dff2da6ad1d6 100644
--- a/clang/test/CoverageMapping/preprocessor.c
+++ b/clang/test/CoverageMapping/preprocessor.c
@@ -1,7 +1,7 @@
 // RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name preprocessor.c %s | FileCheck %s
 
 // CHECK: func
-void func() {    // CHECK: File 0, [[@LINE]]:13 -> [[@LINE+5]]:2 = #0
+void func(void) {// CHECK: File 0, [[@LINE]]:17 -> [[@LINE+5]]:2 = #0
   int i = 0;
 #ifdef MACRO     // CHECK-NEXT: Skipped,File 0, [[@LINE]]:1 -> [[@LINE+2]]:7 = 0
   int x = i;
@@ -9,7 +9,7 @@ void func() {    // CHECK: File 0, [[@LINE]]:13 -> [[@LINE+5]]:2 = #0
 }
 
                  // CHECK: main
-int main() {     // CHECK-NEXT: File 0, [[@LINE]]:12 -> {{[0-9]+}}:2 = #0
+int main(void) { // CHECK-NEXT: File 0, [[@LINE]]:16 -> {{[0-9]+}}:2 = #0
   int i = 0;
 #if 0 // CHECK-NEXT: Skipped,File 0, [[@LINE]]:1 -> [[@LINE+4]]:29 = 0
   if(i == 0) {
diff --git a/clang/test/CoverageMapping/return.c b/clang/test/CoverageMapping/return.c
index 4b26c6d0df98..c2f3c85c5ca7 100644
--- a/clang/test/CoverageMapping/return.c
+++ b/clang/test/CoverageMapping/return.c
@@ -1,13 +1,13 @@
 // RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name return.c %s | FileCheck %s
 
 // CHECK: func
-void func() {                   // CHECK: File 0, [[@LINE]]:13 -> [[@LINE+3]]:2 = #0
+void func(void) {               // CHECK: File 0, [[@LINE]]:17 -> [[@LINE+3]]:2 = #0
   return;                       // CHECK-NEXT: Gap,File 0, [[@LINE]]:10 -> [[@LINE+1]]:3 = 0
   int i = 0;                    // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+1]]:2 = 0
 }
 
                                 // CHECK-NEXT: func2
-void func2() {                  // CHECK-NEXT: File 0, [[@LINE]]:14 -> {{[0-9]+}}:2 = #0
+void func2(void) {              // CHECK-NEXT: File 0, [[@LINE]]:18 -> {{[0-9]+}}:2 = #0
                                 // CHECK-NEXT: File 0, [[@LINE+3]]:18 -> [[@LINE+3]]:24 = ((#0 + #1) - #2)
                                 // CHECK-NEXT: Branch,File 0, [[@LINE+2]]:18 -> [[@LINE+2]]:24 = #1, (#0 - #2)
                                 // CHECK-NEXT: File 0, [[@LINE+1]]:26 -> [[@LINE+1]]:29 = (#1 - #2)
diff --git a/clang/test/CoverageMapping/switchmacro.c b/clang/test/CoverageMapping/switchmacro.c
index 9cf6d13bc3b3..4c98cc7d9403 100644
--- a/clang/test/CoverageMapping/switchmacro.c
+++ b/clang/test/CoverageMapping/switchmacro.c
@@ -30,7 +30,7 @@ int foo(int i) { // CHECK-NEXT: File 0, [[@LINE]]:16 -> {{[0-9]+}}:2 = #0
 // CHECK: bar
 #define START { while (0) { switch (0) {
 #define END   }}}
-void bar() {
+void bar(void) {
   START      // CHECK: File 0, [[@LINE]]:8 -> [[@LINE+2]]:6
 default: ;
   END
@@ -39,7 +39,7 @@ default: ;
 // PR27948 - Crash when handling a switch partially covered by a macro
 // CHECK: baz
 #define START2 switch (0) default:
-void baz() {
+void baz(void) {
   for (;;)
     START2 return; // CHECK: Expansion,File 0, [[@LINE]]:5 -> [[@LINE]]:11 = #1 (Expanded file = 1)
 }
diff --git a/clang/test/CoverageMapping/test.c b/clang/test/CoverageMapping/test.c
index e0c01986fb2b..9ebae5537bb1 100644
--- a/clang/test/CoverageMapping/test.c
+++ b/clang/test/CoverageMapping/test.c
@@ -1,10 +1,10 @@
 // RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name test.c %s | FileCheck %s
 
-void bar();
-static void static_func();
+void bar(void);
+static void static_func(void);
 
                                  // CHECK: main
-int main() {                     // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+8]]:2 = #0
+int main(void) {                 // CHECK-NEXT: File 0, [[@LINE]]:16 -> [[@LINE+8]]:2 = #0
                                  // CHECK-NEXT: File 0, [[@LINE+2]]:18 -> [[@LINE+2]]:24 = (#0 + #1)
                                  // CHECK-NEXT: Branch,File 0, [[@LINE+1]]:18 -> [[@LINE+1]]:24 = #1, #0
   for(int i = 0; i < 10; ++i) {  // CHECK-NEXT: File 0, [[@LINE]]:26 -> [[@LINE]]:29 = #1
@@ -15,7 +15,7 @@ int main() {                     // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+
 }
 
                                  // CHECK-NEXT: foo
-void foo() {                     // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+5]]:2 = #0
+void foo(void) {                 // CHECK-NEXT: File 0, [[@LINE]]:16 -> [[@LINE+5]]:2 = #0
                                  // CHECK-NEXT: File 0, [[@LINE+1]]:6 -> [[@LINE+1]]:7 = #0
   if(1) {                        // CHECK: File 0, [[@LINE]]:9 -> [[@LINE+2]]:4 = #1
     int i = 0;
@@ -23,11 +23,11 @@ void foo() {                     // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+
 }
 
                                  // CHECK-NEXT: bar
-void bar() {                     // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+1]]:2 = #0
+void bar(void) {                 // CHECK-NEXT: File 0, [[@LINE]]:16 -> [[@LINE+1]]:2 = #0
 }
 
                                  // CHECK-NEXT: static_func
-void static_func() { }           // CHECK: File 0, [[@LINE]]:20 -> [[@LINE]]:23 = #0
+void static_func(void) { }       // CHECK: File 0, [[@LINE]]:24 -> [[@LINE]]:27 = #0
 
                                  // CHECK-NEXT: func
-static void func() { }           // CHECK: File 0, [[@LINE]]:20 -> [[@LINE]]:23 = 0
+static void func(void) { }       // CHECK: File 0, [[@LINE]]:24 -> [[@LINE]]:27 = 0
diff --git a/clang/test/CoverageMapping/unreachable-macro.c b/clang/test/CoverageMapping/unreachable-macro.c
index 163aef022491..7956c973f6ce 100644
--- a/clang/test/CoverageMapping/unreachable-macro.c
+++ b/clang/test/CoverageMapping/unreachable-macro.c
@@ -3,8 +3,8 @@
 #define WHILE while (0) {}
 
 // CHECK: counters_in_macro_following_unreachable
-void counters_in_macro_following_unreachable() {
-  // CHECK-NEXT: File 0, [[@LINE-1]]:48 -> {{[0-9]+}}:2 = #0
+void counters_in_macro_following_unreachable(void) {
+  // CHECK-NEXT: File 0, [[@LINE-1]]:52 -> {{[0-9]+}}:2 = #0
   return;
   // CHECK-NEXT: Gap,File 0, [[@LINE-1]]:10 -> [[@LINE+3]]:3 = 0
   // CHECK-NEXT: Expansion,File 0, [[@LINE+2]]:3 -> [[@LINE+2]]:8 = 0
diff --git a/clang/test/CoverageMapping/unused_names.c b/clang/test/CoverageMapping/unused_names.c
index 3076d8321d0b..2aaff2be35c9 100644
--- a/clang/test/CoverageMapping/unused_names.c
+++ b/clang/test/CoverageMapping/unused_names.c
@@ -16,15 +16,15 @@
 #ifdef IS_SYSHEADER
 
 #pragma clang system_header
-inline int foo() { return 0; }
+inline int foo(void) { return 0; }
 
 #else
 
 #define IS_SYSHEADER
 #include __FILE__
 
-int bar() { return 0; }
-inline int baz() { return 0; }
-static int qux() { return 42; }
+int bar(void) { return 0; }
+inline int baz(void) { return 0; }
+static int qux(void) { return 42; }
 
 #endif
diff --git a/clang/test/CoverageMapping/while.c b/clang/test/CoverageMapping/while.c
index f62b0cefe21a..ed5396633bde 100644
--- a/clang/test/CoverageMapping/while.c
+++ b/clang/test/CoverageMapping/while.c
@@ -1,7 +1,7 @@
 // RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name loops.cpp %s | FileCheck %s
 
 // CHECK: main
-int main() {                        // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+10]]:2 = #0
+int main(void) {                    // CHECK-NEXT: File 0, [[@LINE]]:16 -> [[@LINE+10]]:2 = #0
   int j = 0;                        // CHECK-NEXT: File 0, [[@LINE+1]]:9 -> [[@LINE+1]]:14 = (#0 + #1)
   while(j < 5) ++j;                 // CHECK-NEXT: Branch,File 0, [[@LINE]]:9 -> [[@LINE]]:14 = #1, #0
                                     // CHECK-NEXT: File 0, [[@LINE-1]]:15 -> [[@LINE-1]]:16 = #1
diff --git a/clang/test/Parser/namelookup-bug-2.c b/clang/test/Parser/namelookup-bug-2.c
index 4598da05cd02..46f7685f180e 100644
--- a/clang/test/Parser/namelookup-bug-2.c
+++ b/clang/test/Parser/namelookup-bug-2.c
@@ -5,7 +5,7 @@ typedef int Object;
 
 struct Object {int i1; } *P;
 
-void foo() {
+void foo(void) {
  struct Object { int i2; } *X;
   Object:
  {
diff --git a/clang/test/Parser/no-gnu-inline-asm.c b/clang/test/Parser/no-gnu-inline-asm.c
index eda9e0fed6aa..30d4489487df 100644
--- a/clang/test/Parser/no-gnu-inline-asm.c
+++ b/clang/test/Parser/no-gnu-inline-asm.c
@@ -6,7 +6,7 @@
 
 asm ("INST r1, 0"); // expected-error {{GNU-style inline assembly is disabled}}
 
-void foo() __asm("__foo_func"); // AsmLabel is OK
+void foo(void) __asm("__foo_func"); // AsmLabel is OK
 int foo1 asm("bar1") = 0; // OK
 
 asm(" "); // Whitespace is OK
diff --git a/clang/test/Parser/objc-alias-printing.m b/clang/test/Parser/objc-alias-printing.m
index 8b9cc6e13924..0f76ec367483 100644
--- a/clang/test/Parser/objc-alias-printing.m
+++ b/clang/test/Parser/objc-alias-printing.m
@@ -8,7 +8,7 @@
 @compatibility_alias alias INTF;
 
 
-int foo ()
+int foo (void)
 {
 	INTF *pi;
 	INTF<P2,P1> *pi2;
diff --git a/clang/test/Parser/objc-at-directive-fixit.m b/clang/test/Parser/objc-at-directive-fixit.m
index dcf695d3aaa2..1d291177d4ce 100644
--- a/clang/test/Parser/objc-at-directive-fixit.m
+++ b/clang/test/Parser/objc-at-directive-fixit.m
@@ -5,7 +5,7 @@
 
 void bar(int x);
 
-void f() {
+void f(void) {
   @try { }
   @finally { }
   @autoreleasepool { }
diff --git a/clang/test/Parser/objc-available.m b/clang/test/Parser/objc-available.m
index 01d59f8f5253..3332f828abf2 100644
--- a/clang/test/Parser/objc-available.m
+++ b/clang/test/Parser/objc-available.m
@@ -1,6 +1,6 @@
 // RUN: %clang_cc1 -fsyntax-only -Wunguarded-availability -Wno-unsupported-availability-guard -triple x86_64-apple-macosx10.10.0 -verify %s
 
-void f() {
+void f(void) {
 
   if (@available(macos 10.12, *)) {}
   else if (@available(macos 10.11, *)) {}
@@ -21,7 +21,7 @@ void f() {
   (void)@available; // expected-error{{expected '('}}
 }
 
-void prettyPlatformNames() {
+void prettyPlatformNames(void) {
   (void)@available(iOS 8, tvOS 10, watchOS 3, macOS 10.11, *);
   (void)__builtin_available(iOSApplicationExtension 8, tvOSApplicationExtension 10,
                    watchOSApplicationExtension 3, macOSApplicationExtension 10.11, *);
diff --git a/clang/test/Parser/objc-boxing.m b/clang/test/Parser/objc-boxing.m
index a6bb0243cf0e..16737bc1c560 100644
--- a/clang/test/Parser/objc-boxing.m
+++ b/clang/test/Parser/objc-boxing.m
@@ -8,19 +8,19 @@
 
 extern char *strdup(const char *str);
 
-id constant_string() {
+id constant_string(void) {
     return @("boxed constant string.");
 }
 
-id dynamic_string() {
+id dynamic_string(void) {
     return @(strdup("boxed dynamic string"));
 }
 
-id const_char_pointer() {
+id const_char_pointer(void) {
     return @((const char *)"constant character pointer");
 }
 
-id missing_parentheses() {
+id missing_parentheses(void) {
     return @(5;             // expected-error {{expected ')'}} \
                             // expected-note {{to match this '('}}
 }
diff --git a/clang/test/Parser/objc-class-property.m b/clang/test/Parser/objc-class-property.m
index e4c3b0766b4a..afb8a44fa224 100644
--- a/clang/test/Parser/objc-class-property.m
+++ b/clang/test/Parser/objc-class-property.m
@@ -23,7 +23,7 @@
 @dynamic c;
 @end
 
-int test() {
+int test(void) {
   A *a = [[A alloc] init];
   return a.x;
 }
diff --git a/clang/test/Parser/objc-foreach-syntax.m b/clang/test/Parser/objc-foreach-syntax.m
index 0f4a14f2b785..e446eb576c1a 100644
--- a/clang/test/Parser/objc-foreach-syntax.m
+++ b/clang/test/Parser/objc-foreach-syntax.m
@@ -9,7 +9,7 @@ struct __objcFastEnumerationState;
 @end
 
 
-int LOOP();
+int LOOP(void);
 
 @implementation MyList (BasicTest) 
 - (void)compilerTestAgainst {
diff --git a/clang/test/Parser/objc-init.m b/clang/test/Parser/objc-init.m
index 04e0c823fc67..924014dc1c19 100644
--- a/clang/test/Parser/objc-init.m
+++ b/clang/test/Parser/objc-init.m
@@ -13,7 +13,7 @@ struct SomeStruct {
   int x, y, z, q;
 };
 
-void test1() {
+void test1(void) {
 	id objects[] = {[NSNumber METH]};
 }
 
@@ -27,7 +27,7 @@ void test3(NSNumber *x) {
 
 
 // rdar://5977581
-void test4() {
+void test4(void) {
   unsigned x[] = {[NSNumber METH2]+2};
 }
 
diff --git a/clang/test/Parser/objc-messaging-1.m b/clang/test/Parser/objc-messaging-1.m
index 6c0b78d63b87..b6a60733d2b6 100644
--- a/clang/test/Parser/objc-messaging-1.m
+++ b/clang/test/Parser/objc-messaging-1.m
@@ -1,5 +1,5 @@
 // RUN: %clang_cc1 %s -fsyntax-only -verify
-int main ()
+int main (void)
 {
 	int i,j;
 	struct S *p;
diff --git a/clang/test/Parser/objc-messaging-neg-1.m b/clang/test/Parser/objc-messaging-neg-1.m
index bb496e96914e..daa2ab99aff8 100644
--- a/clang/test/Parser/objc-messaging-neg-1.m
+++ b/clang/test/Parser/objc-messaging-neg-1.m
@@ -4,7 +4,7 @@
 +(void) foo:(int) a;
 @end
 
-int main() {
+int main(void) {
   id a;
   [a bla:0 6:7]; // expected-error {{expected ']'}}
   [A foo bar]; // expected-error {{expected ':'}}
diff --git a/clang/test/Parser/objc-try-catch-1.m b/clang/test/Parser/objc-try-catch-1.m
index 102d782f58e5..9969fb5e56c3 100644
--- a/clang/test/Parser/objc-try-catch-1.m
+++ b/clang/test/Parser/objc-try-catch-1.m
@@ -1,6 +1,6 @@
 // RUN: %clang_cc1 -triple x86_64-apple-macosx10.10 -fsyntax-only -verify -fobjc-exceptions %s
 // RUN: %clang_cc1 -triple x86_64-apple-macosx10.10 -fsyntax-only -verify -fobjc-exceptions -x objective-c++ %s
-void * proc();
+void * proc(void);
 
 @interface NSConstantString
 @end
@@ -11,7 +11,7 @@ void * proc();
 @interface Frob1
 @end
 
-void * foo()
+void * foo(void)
 {
   @try {
     return proc();
@@ -44,20 +44,20 @@ void * foo()
 }
 
 
-void bar()
+void bar(void)
 {
   @try {}// expected-error {{@try statement without a @catch and @finally clause}}
   @"s"; //  expected-warning {{result unused}}
 }
 
-void baz()
+void baz(void)
 {
   @try {}// expected-error {{@try statement without a @catch and @finally clause}}
   @try {}
   @finally {}
 }
 
-void noTwoTokenLookAheadRequiresABitOfFancyFootworkInTheParser() {
+void noTwoTokenLookAheadRequiresABitOfFancyFootworkInTheParser(void) {
     @try {
         // Do something
     } @catch (...) {}
diff --git a/clang/test/Parser/objc-type-printing.m b/clang/test/Parser/objc-type-printing.m
index 9bbdac98bcbd..0cb6bbb54433 100644
--- a/clang/test/Parser/objc-type-printing.m
+++ b/clang/test/Parser/objc-type-printing.m
@@ -8,7 +8,7 @@
 - (INTF<P1>*) METH;
 @end
 
-void foo()
+void foo(void)
 {
         INTF *pintf;
 	INTF<P1>* p1;
diff --git a/clang/test/Parser/pointer_promotion.c b/clang/test/Parser/pointer_promotion.c
index 8b718ad565ce..d18d0ca4d1a6 100644
--- a/clang/test/Parser/pointer_promotion.c
+++ b/clang/test/Parser/pointer_promotion.c
@@ -1,6 +1,6 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
-void test() {
+void test(void) {
   void *vp;
   int *ip;
   char *cp;
diff --git a/clang/test/Parser/pragma-fenv_access-ms.c b/clang/test/Parser/pragma-fenv_access-ms.c
index d179dfeb8780..b00c82dd6a4b 100644
--- a/clang/test/Parser/pragma-fenv_access-ms.c
+++ b/clang/test/Parser/pragma-fenv_access-ms.c
@@ -10,7 +10,7 @@
 #pragma fenv_access (on // expected-warning{{missing ')' after '#pragma fenv_access'}}
 #pragma fenv_access (on) foo // expected-warning{{extra tokens at end of '#pragma fenv_access'}}
 
-void f() {
+void f(void) {
   (void)0;
   #pragma fenv_access (on) // expected-error{{'#pragma fenv_access' can only appear at file scope or at the start of a compound statement}}
 }
diff --git a/clang/test/Parser/pragma-fenv_access.c b/clang/test/Parser/pragma-fenv_access.c
index 3c003d124286..76256cff1b49 100644
--- a/clang/test/Parser/pragma-fenv_access.c
+++ b/clang/test/Parser/pragma-fenv_access.c
@@ -19,7 +19,7 @@ float func_04(int x, float y) {
 }
 
 #pragma STDC FENV_ACCESS ON
-int main() {
+int main(void) {
   CONST float one = 1.0F ;
   CONST float three = 3.0F ;
   CONST float four = 4.0F ;
diff --git a/clang/test/Parser/recovery.c b/clang/test/Parser/recovery.c
index 178427e4b3c2..1e76c60a2420 100644
--- a/clang/test/Parser/recovery.c
+++ b/clang/test/Parser/recovery.c
@@ -62,7 +62,7 @@ struct S A = {
 };
 
 // rdar://6248081
-void test6248081() { 
+void test6248081(void) { 
   [10]  // expected-error {{expected expression}}
 }
 
@@ -70,7 +70,7 @@ struct forward; // expected-note{{forward declaration of 'struct forward'}}
 void x(struct forward* x) {switch(x->a) {}} // expected-error {{incomplete definition of type}}
 
 // PR3410
-void foo() {
+void foo(void) {
   int X;
   X = 4 // expected-error{{expected ';' after expression}}
 }
diff --git a/clang/test/Parser/selector-1.m b/clang/test/Parser/selector-1.m
index 3e2a86d9e9b2..de8ee030ae2c 100644
--- a/clang/test/Parser/selector-1.m
+++ b/clang/test/Parser/selector-1.m
@@ -3,7 +3,7 @@
 // expected-no-diagnostics
 
 // rdar://8366474
-int main() {
+int main(void) {
   SEL s = @selector(retain);
   SEL s1 = @selector(meth1:);
   SEL s2 = @selector(retainArgument::);
diff --git a/clang/test/Parser/sizeof-missing-parens.c b/clang/test/Parser/sizeof-missing-parens.c
index 527f74151be1..8f7f728354b6 100644
--- a/clang/test/Parser/sizeof-missing-parens.c
+++ b/clang/test/Parser/sizeof-missing-parens.c
@@ -4,7 +4,7 @@ void Foo(int);
 
 #define Bar(x) Foo(x)
 
-void Baz() {
+void Baz(void) {
   Foo(sizeof int); // expected-error {{expected parentheses around type name in sizeof expression}}
   Bar(sizeof int); // expected-error {{expected parentheses around type name in sizeof expression}}
 }
diff --git a/clang/test/Parser/statements.c b/clang/test/Parser/statements.c
index 8215f4c92a60..2566da83d7c5 100644
--- a/clang/test/Parser/statements.c
+++ b/clang/test/Parser/statements.c
@@ -1,10 +1,10 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s -Wno-unreachable-code
 
-void test1() {
+void test1(void) {
   { ; {  ;;}} ;;
 }
 
-void test2() {
+void test2(void) {
   if (0) { if (1) {} } else { }
 
   do { } while (0); 
@@ -18,7 +18,7 @@ void test2() {
   for (int X = 0; 0; (void)0);
 }
 
-void test3() {
+void test3(void) {
     switch (0) {
     
     case 4:
@@ -30,7 +30,7 @@ void test3() {
   }
 }
 
-void test4() {
+void test4(void) {
   if (0);  // expected-warning {{if statement has empty body}} expected-note {{put the semicolon on a separate line to silence this warning}}
   
   int X;  // declaration in a block.
@@ -39,7 +39,7 @@ foo:  if (0); // expected-warning {{if statement has empty body}} expected-note
 }
 
 typedef int t;
-void test5() {
+void test5(void) {
   if (0);   // expected-warning {{if statement has empty body}} expected-note {{put the semicolon on a separate line to silence this warning}}
 
   t x = 0;
@@ -54,16 +54,16 @@ void test6(void) {
    while (0);
 }
 
-int test7() {
+int test7(void) {
   return 4     // expected-error {{expected ';' after return statement}}
 }
 
-void test8() {
+void test8(void) {
   // Should not skip '}' and produce a "expected '}'" error.
   undecl // expected-error {{use of undeclared identifier 'undecl'}}
 }
 
-int test9() {
+int test9(void) {
   int T[] = {1, 2, };
 
   int X;
diff --git a/clang/test/Parser/stmt-attributes.c b/clang/test/Parser/stmt-attributes.c
index 86adc56f40ca..52061afd7bc1 100644
--- a/clang/test/Parser/stmt-attributes.c
+++ b/clang/test/Parser/stmt-attributes.c
@@ -71,9 +71,9 @@ void foo(int i) {
   __attribute__((carries_dependency)) return; // expected-error {{'carries_dependency' attribute cannot be applied to a statement}}
 }
 
-void bar();
+void bar(void);
 
-void foobar() {
+void foobar(void) {
   __attribute__((nomerge)) bar();
   __attribute__(()) bar();                // expected-error {{expected identifier or '('}}
   __attribute__((unused, nomerge)) bar(); // expected-error {{expected identifier or '('}}
@@ -85,6 +85,6 @@ void foobar() {
   __attribute__((nomerge)) label : bar(); // expected-error {{'nomerge' attribute only applies to functions and statements}}
 }
 
-int f();
+int f(void);
 
 __attribute__((nomerge)) static int i; // expected-error {{'nomerge' attribute only applies to functions and statements}}
diff --git a/clang/test/Parser/stmt-attributes.m b/clang/test/Parser/stmt-attributes.m
index 550781b5311a..a138580d6717 100644
--- a/clang/test/Parser/stmt-attributes.m
+++ b/clang/test/Parser/stmt-attributes.m
@@ -15,7 +15,7 @@
 - (void)bar;
 @end
 
-Test *getTest();
+Test *getTest(void);
 
 @implementation Test
 - (void)foo __attribute__((nomerge)) {
diff --git a/clang/test/Parser/typeof.c b/clang/test/Parser/typeof.c
index 7953a69fed00..69833f3161dd 100644
--- a/clang/test/Parser/typeof.c
+++ b/clang/test/Parser/typeof.c
@@ -2,7 +2,7 @@
 
 typedef int TInt;
 
-static void test() {
+static void test(void) {
   int *pi;
 
   int typeof (int) aIntInt; // expected-error{{cannot combine with previous 'int' declaration specifier}}
@@ -19,7 +19,7 @@ static void test() {
 }
 
 // <rdar://problem/8237491>
-void test2() {
+void test2(void) {
     int a;
     short b;
     __typeof__(a) (*f)(__typeof__(b));    
diff --git a/clang/test/Parser/types.c b/clang/test/Parser/types.c
index db8c08303f57..58ace6d16610 100644
--- a/clang/test/Parser/types.c
+++ b/clang/test/Parser/types.c
@@ -8,7 +8,7 @@ struct Y { short X; };
 // Variable shadows type, PR3872
 
 typedef struct foo { int x; } foo;
-void test() {
+void test(void) {
    foo *foo;
    foo->x = 0;
 }
diff --git a/clang/test/Parser/warn-misleading-indentation.cpp b/clang/test/Parser/warn-misleading-indentation.cpp
index 8339f21099c3..f7339954f911 100644
--- a/clang/test/Parser/warn-misleading-indentation.cpp
+++ b/clang/test/Parser/warn-misleading-indentation.cpp
@@ -227,7 +227,7 @@ void s(int num) {
 // expected-warning@-2 {{misleading indentation; statement is not part of the previous 'if'}}
 #endif
 }
-int a4()
+int a4(void)
 {
 	if (0)
 		return 1;
@@ -238,7 +238,7 @@ int a4()
 #endif 
 }
 
-int a5()
+int a5(void)
 {
 	if (0)
 		return 1;
@@ -249,7 +249,7 @@ int a5()
 #endif
 }
 
-int a6()
+int a6(void)
 {
 	if (0)
 		return 1;