Dump functions attribute right before their return type

[giulianobelinassi]

Summary

GCC rejects the following kind of dumps:

int f(void) attribute((unused))
{

return 0;

}

because of the following reason: Assume the function is K&R declared:

int f(i) attribute((unused))

int i;

{

return 0;

}

Now, to which symbol should the attribute((unused)) be applied?
Depending of the parsing strategy, this will be either applied to
f or i, but likely this will be applied to f as the compiler parses
from left-to-right.

GCC, therefore, rejects this kind of declarations altogether. Clang
even warns that such declarations won't be accepted by GCC. Since
an user may be using clang dumps as a library to do static analysis
and outputing code that will be fed into GCC, then instead of dumping:

int f(void) attribute((unused));

this patch modifies such cases to output to:

int attribute((unused)) f(void);

causing GCC to also accept such dumps.

Signed-off-by: Giuliano Belinassi <[e-mail]>

Depends on: D141714

clang/lib/AST/DeclPrinter.cpp

if (!Policy.SuppressSpecifiers) {
     if (ExplicitSpec.isSpecified())
       printExplicitSpecifier(ExplicitSpec, Out, Policy, Indentation, Context);
   }
 
   PrintingPolicy SubPolicy(Policy);
   SubPolicy.SuppressSpecifiers = false;
   std::string Proto;
 
+  llvm::raw_string_ostream OS(Proto);
+  prettyPrintAttributes(D, OS, SIDE_MIDDLE);
+
+  // prettyPrintAttributes print a space on left side of the attribute.
+  if (Proto[0] == ' ') {
+    // Skip the space prettyPrintAttributes generated.
+    Proto.erase(0, Proto.find_first_not_of(' '));
+
+    // Add a single space between the attribute and the Decl name.
+    OS << ' ';
+  }
+
   if (Policy.FullyQualifiedName) {
     Proto += D->getQualifiedNameAsString();
   } else {
-    llvm::raw_string_ostream OS(Proto);
     if (!Policy.SuppressScope) {
       if (const NestedNameSpecifier *NS = D->getQualifier()) {
         NS->print(OS, Policy);
       }
     }
     D->getNameInfo().printName(OS, Policy);
   }
 
if (Expr *TrailingRequiresClause = D->getTrailingRequiresClause()) {
       Out << " requires ";
       TrailingRequiresClause->printPretty(Out, nullptr, SubPolicy, Indentation,
                                           "\n", &Context);
     }
   } else {
     Ty.print(Out, Policy, Proto);
   }
 
-  prettyPrintAttributes(D);
+  prettyPrintAttributes(D, Out, SIDE_RIGHT);
 
   if (D->isPure())
     Out << " = 0";
   else if (D->isDeletedAsWritten())
     Out << " = delete";
   else if (D->isExplicitlyDefaulted())
     Out << " = default";
   else if (D->doesThisDeclarationHaveABody()) {

clang/test/AST/ast-print-attr-knr.c

 // This file contain tests for attribute arguments on K&R functions.
 
 // RUN: %clang_cc1 -ast-print -x c -std=c89 -fms-extensions %s -o - | FileCheck %s
 
 // CHECK: int knr(i)
 // CHECK-NEXT: int __attribute__((unused)) i;
 // CHECK-NEXT: {
 // CHECK-NEXT: return 0;
 // CHECK-NEXT: }
 int knr(i) int __attribute__((unused)) i; { return 0; }
+
+// CHECK: int __attribute__((unused)) knr2(i)
+// CHECK-NEXT: int i;
+// CHECK-NEXT: {
+// CHECK-NEXT: return 0;
+// CHECK-NEXT: }
+int __attribute__((unused)) knr2(i) int i; { return 0; }

clang/test/AST/ast-print-attr.c

 
 extern NSString *const MyErrorDomain;
 // CHECK: enum __attribute__((ns_error_domain(MyErrorDomain))) MyErrorEnum {
 enum __attribute__((ns_error_domain(MyErrorDomain))) MyErrorEnum {
   MyErrFirst,
   MyErrSecond,
 };
 
-// CHECK: int *fun_returns() __attribute__((ownership_returns(fun_returns)));
-int *fun_returns() __attribute__((ownership_returns(fun_returns)));
+// CHECK: int *__attribute__((ownership_returns(fun_returns))) fun_returns();
+int *__attribute__((ownership_returns(fun_returns))) fun_returns();
 
-// CHECK: void fun_holds(int *a) __attribute__((ownership_holds(fun_holds, 1)));
-void fun_holds(int *a) __attribute__((ownership_holds(fun_holds, 1)));
+// CHECK: void __attribute__((ownership_holds(fun_holds, 1))) fun_holds(int *a);
+void __attribute__((ownership_holds(fun_holds, 1))) fun_holds(int *a);
 
 // CHECK: int fun_var_unused() {
 // CHECK-NEXT: int __attribute__((unused)) x = 0;
 // CHECK-NEXT: return x;
 // CHECK-NEXT: }
 int fun_var_unused() { int __attribute__((unused)) x = 0; return x; }

clang/test/AST/ast-print-no-sanitize.cpp

 // RUN: %clang_cc1 -std=c++11 -ast-print %s -o - | FileCheck %s
 
 void should_not_crash_1() __attribute__((no_sanitize_memory));
 [[clang::no_sanitize_memory]] void should_not_crash_2();
 
-// CHECK: void should_not_crash_1() __attribute__((no_sanitize("memory")));
+// CHECK: void __attribute__((no_sanitize("memory"))) should_not_crash_1();
 // CHECK: void should_not_crash_2() {{\[\[}}clang::no_sanitize("memory"){{\]\]}};

clang/test/AST/attr-print-emit.cpp

 // RUN: %clang_cc1 %s -ast-print | FileCheck %s
 // RUN: %clang -emit-ast -o %t.ast %s
 // RUN: %clang_cc1 %t.ast -ast-print | FileCheck %s
 
-// CHECK: void xla(int a) __attribute__((xray_log_args(1)));
+// CHECK: void __attribute__((xray_log_args(1))) xla(int a);
 void xla(int a) __attribute__((xray_log_args(1)));
 
-// CHECK: void *as2(int, int) __attribute__((alloc_size(1, 2)));
+// CHECK: void *__attribute__((alloc_size(1, 2))) as2(int, int);
 void *as2(int, int) __attribute__((alloc_size(1, 2)));
-// CHECK: void *as1(void *, int) __attribute__((alloc_size(2)));
+// CHECK: void *__attribute__((alloc_size(2))) as1(void *, int);
 void *as1(void *, int) __attribute__((alloc_size(2)));
 
-// CHECK: void fmt(int, const char *, ...) __attribute__((format(printf, 2, 3)));
+// CHECK: void __attribute__((format(printf, 2, 3))) fmt(int, const char *, ...);
 void fmt(int, const char *, ...) __attribute__((format(printf, 2, 3)));
 
-// CHECK: char *fmta(int, const char *) __attribute__((format_arg(2)));
+// CHECK: char *__attribute__((format_arg(2))) fmta(int, const char *);
 char *fmta(int, const char *) __attribute__((format_arg(2)));
 
-// CHECK: void nn(int *, int *) __attribute__((nonnull(1, 2)));
+// CHECK: void __attribute__((nonnull(1, 2))) nn(int *, int *);
 void nn(int *, int *) __attribute__((nonnull(1, 2)));
 
-// CHECK: int *aa(int i) __attribute__((alloc_align(1)));
+// CHECK: int *__attribute__((alloc_align(1))) aa(int i);
 int *aa(int i) __attribute__((alloc_align(1)));
 
-// CHECK: void ownt(int *, int *) __attribute__((ownership_takes(foo, 1, 2)));
+// CHECK: void __attribute__((ownership_takes(foo, 1, 2))) ownt(int *, int *);
 void ownt(int *, int *) __attribute__((ownership_takes(foo, 1, 2)));
-// CHECK: void ownh(int *, int *) __attribute__((ownership_holds(foo, 1, 2)));
+// CHECK: void __attribute__((ownership_holds(foo, 1, 2))) ownh(int *, int *);
 void ownh(int *, int *) __attribute__((ownership_holds(foo, 1, 2)));
-// CHECK: void ownr(int) __attribute__((ownership_returns(foo, 1)));
+// CHECK: void __attribute__((ownership_returns(foo, 1))) ownr(int);
 void ownr(int) __attribute__((ownership_returns(foo, 1)));
 
-// CHECK: void awtt(int, int, ...) __attribute__((argument_with_type_tag(foo, 3, 2)));
+// CHECK: void __attribute__((argument_with_type_tag(foo, 3, 2))) awtt(int, int, ...);
 void awtt(int, int, ...) __attribute__((argument_with_type_tag(foo, 3, 2)));
-// CHECK: void pwtt(void *, int) __attribute__((pointer_with_type_tag(foo, 1, 2)));
+// CHECK: void __attribute__((pointer_with_type_tag(foo, 1, 2))) pwtt(void *, int);
 void pwtt(void *, int) __attribute__((pointer_with_type_tag(foo, 1, 2)));
 
 class C {
-  // CHECK: void xla(int a) __attribute__((xray_log_args(2)));
+  // CHECK: void __attribute__((xray_log_args(2))) xla(int a);
   void xla(int a) __attribute__((xray_log_args(2)));
 
-  // CHECK: void *as2(int, int) __attribute__((alloc_size(2, 3)));
+  // CHECK: void *__attribute__((alloc_size(2, 3))) as2(int, int);
   void *as2(int, int) __attribute__((alloc_size(2, 3)));
-  // CHECK: void *as1(void *, int) __attribute__((alloc_size(3)));
+  // CHECK: void *__attribute__((alloc_size(3))) as1(void *, int);
   void *as1(void *, int) __attribute__((alloc_size(3)));
 
-  // CHECK: void fmt(int, const char *, ...) __attribute__((format(printf, 3, 4)));
+  // CHECK: void __attribute__((format(printf, 3, 4))) fmt(int, const char *, ...);
   void fmt(int, const char *, ...) __attribute__((format(printf, 3, 4)));
 
-  // CHECK: char *fmta(int, const char *) __attribute__((format_arg(3)));
+  // CHECK: char *__attribute__((format_arg(3))) fmta(int, const char *);
   char *fmta(int, const char *) __attribute__((format_arg(3)));
 
-  // CHECK: void nn(int *, int *) __attribute__((nonnull(2, 3)));
+  // CHECK: void __attribute__((nonnull(2, 3))) nn(int *, int *);
   void nn(int *, int *) __attribute__((nonnull(2, 3)));
 
-  // CHECK: int *aa(int i) __attribute__((alloc_align(2)));
+  // CHECK: int *__attribute__((alloc_align(2))) aa(int i);
   int *aa(int i) __attribute__((alloc_align(2)));
 
-  // CHECK: void ownt(int *, int *) __attribute__((ownership_takes(foo, 2, 3)));
+  // CHECK: void __attribute__((ownership_takes(foo, 2, 3))) ownt(int *, int *);
   void ownt(int *, int *) __attribute__((ownership_takes(foo, 2, 3)));
-  // CHECK: void ownh(int *, int *) __attribute__((ownership_holds(foo, 2, 3)));
+  // CHECK: void __attribute__((ownership_holds(foo, 2, 3))) ownh(int *, int *);
   void ownh(int *, int *) __attribute__((ownership_holds(foo, 2, 3)));
-  // CHECK: void ownr(int) __attribute__((ownership_returns(foo, 2)));
+  // CHECK: void __attribute__((ownership_returns(foo, 2))) ownr(int);
   void ownr(int) __attribute__((ownership_returns(foo, 2)));
 
-  // CHECK: void awtt(int, int, ...) __attribute__((argument_with_type_tag(foo, 4, 3)));
+  // CHECK: void __attribute__((argument_with_type_tag(foo, 4, 3))) awtt(int, int, ...);
   void awtt(int, int, ...) __attribute__((argument_with_type_tag(foo, 4, 3)));
-  // CHECK: void pwtt(void *, int) __attribute__((pointer_with_type_tag(foo, 2, 3)));
+  // CHECK: void __attribute__((pointer_with_type_tag(foo, 2, 3))) pwtt(void *, int);
   void pwtt(void *, int) __attribute__((pointer_with_type_tag(foo, 2, 3)));
 };

clang/test/Analysis/std-c-library-functions-arg-weakdeps.c

 // RUN:   -analyzer-checker=core \
 // RUN:   -analyzer-checker=apiModeling.StdCLibraryFunctions \
 // RUN:   -analyzer-config apiModeling.StdCLibraryFunctions:ModelPOSIX=true \
 // RUN:   -analyzer-checker=alpha.unix.StdCLibraryFunctionArgs \
 // RUN:   -analyzer-config apiModeling.StdCLibraryFunctions:DisplayLoadedSummaries=true \
 // RUN:   -triple x86_64-unknown-linux 2>&1 | FileCheck %s
 
 // CHECK: Loaded summary for: int isalnum(int)
-// CHECK: Loaded summary for: unsigned long fread(void *restrict, size_t, size_t, FILE *restrict) __attribute__((nonnull(1)))
+// CHECK: Loaded summary for: unsigned long __attribute__((nonnull(1))) fread(void *restrict, size_t, size_t, FILE *restrict)
 // CHECK: Loaded summary for: int fileno(FILE *stream)
 
 void initializeSummaryMap(void);
 // We analyze this function first, and the call expression inside initializes
 // the summary map. This way we force the loading of the summaries. The
 // summaries would not be loaded without this because during the first bug
 // report in WeakDependency::checkPreCall we stop further evaluation. And
 // StdLibraryFunctionsChecker lazily initializes its summary map from its
 // checkPreCall.
 void analyzeThisFirst(void) {
   initializeSummaryMap();
 }
 
 typedef __typeof(sizeof(int)) size_t;
 struct FILE;
 typedef struct FILE FILE;
 
 int isalnum(int);
-size_t fread(void *restrict, size_t, size_t, FILE *restrict) __attribute__((nonnull(1)));
+size_t __attribute__((nonnull(1))) fread(void *restrict, size_t, size_t, FILE *restrict);
 int fileno(FILE *stream);
 
 void test_uninit_arg(void) {
   int v;
   int r = isalnum(v); // \
   // expected-warning{{1st function call argument is an uninitialized value [core.CallAndMessage]}}
   (void)r;
 }
 
 void test_notnull_arg(FILE *F) {
   int *p = 0;
   fread(p, sizeof(int), 5, F); // \
   expected-warning{{Null pointer passed to 1st parameter expecting 'nonnull' [core.NonNullParamChecker]}}
 }

clang/test/OpenMP/assumes_codegen.cpp

 
 #pragma omp begin assumes ext_lambda_assumption
 int lambda_outer() {
   auto lambda_inner = []() { return 42; };
   return lambda_inner();
 }
 #pragma omp end assumes
 
-// AST:      void foo() __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) {
+// AST:      void __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) foo() {
 // AST-NEXT: }
 // AST-NEXT: class BAR {
 // AST-NEXT: public:
-// AST-NEXT:     BAR() __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")))     {
+// AST-NEXT:     __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) BAR()      {
 // AST-NEXT:     }
-// AST-NEXT:     void bar1() __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")))     {
+// AST-NEXT:     void __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) bar1()     {
 // AST-NEXT:     }
-// AST-NEXT:     static void bar2() __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")))     {
+// AST-NEXT:     static void __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) bar2()      {
 // AST-NEXT:     }
 // AST-NEXT: };
-// AST-NEXT: void bar() __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) {
+// AST-NEXT: void __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) bar() {
 // AST-NEXT:     BAR b;
 // AST-NEXT: }
-// AST-NEXT: void baz() __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")));
+// AST-NEXT: void __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) baz();
 // AST-NEXT: template <typename T> class BAZ {
 // AST-NEXT: public:
-// AST-NEXT:     BAZ<T>() __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")))     {
+// AST-NEXT:     __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) BAZ<T>()      {
 // AST-NEXT:     }
-// AST-NEXT:     void baz1() __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")))     {
+// AST-NEXT:     void __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")))  baz1()     {
 // AST-NEXT:     }
-// AST-NEXT:     static void baz2() __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")))     {
+// AST-NEXT:     static void __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) baz2()      {
 // AST-NEXT:     }
 // AST-NEXT: };
 // AST-NEXT: template<> class BAZ<float> {
 // AST-NEXT: public:
-// AST-NEXT:     BAZ() __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")))    {
+// AST-NEXT:     __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")))  BAZ()    {
 // AST-NEXT:     }
-// AST-NEXT:     void baz1() __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")));
-// AST-NEXT:     static void baz2() __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")));
+// AST-NEXT:     void __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) baz1();
+// AST-NEXT:     static void __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) baz2();
 // AST-NEXT: };
-// AST-NEXT: void baz() __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) {
+// AST-NEXT: void __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) baz() {
 // AST-NEXT:     BAZ<float> b;
 // AST-NEXT: }
-// AST-NEXT: int lambda_outer() __attribute__((assume("ompx_lambda_assumption"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) {
+// AST-NEXT: int __attribute__((assume("ompx_lambda_assumption"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) lambda_outer() {
 // AST-NEXT:     auto lambda_inner = []() {
 // AST-NEXT:         return 42;
 // AST-NEXT:     };
 // AST-NEXT:     return lambda_inner();
 // AST-NEXT: }
 
 #endif
 

clang/test/OpenMP/assumes_print.cpp

 #pragma omp begin assumes ext_not_seen
 #pragma omp end assumes
 
 #pragma omp begin assumes ext_1234
 void baz() {
 }
 #pragma omp end assumes
 
-// CHECK: void foo() __attribute__((assume("omp_no_openmp_routines"))) __attribute__((assume("omp_no_openmp")))
-// CHECK: void bar() __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines"))) __attribute__((assume("omp_no_openmp")))
-// CHECK: void baz() __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines"))) __attribute__((assume("omp_no_openmp")))
+// CHECK: void __attribute__((assume("omp_no_openmp_routines"))) __attribute__((assume("omp_no_openmp"))) foo()
+// CHECK: void __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines"))) __attribute__((assume("omp_no_openmp"))) bar()
+// CHECK: void __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines"))) __attribute__((assume("omp_no_openmp"))) baz()
 
 #endif

clang/test/OpenMP/assumes_template_print.cpp

 
 #ifndef HEADER
 #define HEADER
 
 template <typename T>
 struct S {
   int a;
 // CHECK: template <typename T> struct S {
-// CHECK:     void foo() __attribute__((assume("ompx_global_assumption")))     {
+// CHECK:     void __attribute__((assume("ompx_global_assumption"))) foo()     {
   void foo() {
     #pragma omp parallel
     {}
   }
 };
 
 // CHECK: template<> struct S<int> {
-// CHECK:     void foo() __attribute__((assume("ompx_global_assumption")))     {
+// CHECK:     void __attribute__((assume("ompx_global_assumption"))) foo()     {
 
 #pragma omp begin assumes no_openmp
-// CHECK: void S_with_assumes_no_call() __attribute__((assume("omp_no_openmp"))) __attribute__((assume("ompx_global_assumption"))) {
+// CHECK: void __attribute__((assume("omp_no_openmp"))) __attribute__((assume("ompx_global_assumption"))) S_with_assumes_no_call() {
 void S_with_assumes_no_call() {
   S<int> s;
   s.a = 0;
 }
-// CHECK: void S_with_assumes_call() __attribute__((assume("omp_no_openmp"))) __attribute__((assume("ompx_global_assumption"))) {
+// CHECK: void __attribute__((assume("omp_no_openmp"))) __attribute__((assume("ompx_global_assumption"))) S_with_assumes_call() {
 void S_with_assumes_call() {
   S<int> s;
   s.a = 0;
   // If this is executed we have UB!
   s.foo();
 }
 #pragma omp end assumes
 
-// CHECK: void S_without_assumes() __attribute__((assume("ompx_global_assumption"))) {
+// CHECK: void __attribute__((assume("ompx_global_assumption"))) S_without_assumes() {
 void S_without_assumes() {
   S<int> s;
   s.foo();
 }
 
 #pragma omp assumes ext_global_assumption
 
 // Same as the struct S above but the order in which we instantiate P is different, first outside of an assumes.
 template <typename T>
 struct P {
 // CHECK: template <typename T> struct P {
-// CHECK:     void foo() __attribute__((assume("ompx_global_assumption")))     {
+// CHECK:     void __attribute__((assume("ompx_global_assumption"))) foo()      {
   int a;
   void foo() {
     #pragma omp parallel
     {}
   }
 };
 
 // TODO: Avoid the duplication here:
 
 // CHECK: template<> struct P<int> {
-// CHECK:     void foo() __attribute__((assume("ompx_global_assumption"))) __attribute__((assume("ompx_global_assumption")))     {
+// CHECK:     void __attribute__((assume("ompx_global_assumption"))) __attribute__((assume("ompx_global_assumption"))) foo()   {
 
-// CHECK: void P_without_assumes() __attribute__((assume("ompx_global_assumption"))) {
+// CHECK: void  __attribute__((assume("ompx_global_assumption"))) P_without_assumes() {
 void P_without_assumes() {
   P<int> p;
   p.foo();
 }
 
 #pragma omp begin assumes no_openmp
-// CHECK: void P_with_assumes_no_call() __attribute__((assume("omp_no_openmp"))) __attribute__((assume("ompx_global_assumption"))) {
+// CHECK: void __attribute__((assume("omp_no_openmp"))) __attribute__((assume("ompx_global_assumption"))) P_with_assumes_no_call() {
 void P_with_assumes_no_call() {
   P<int> p;
   p.a = 0;
 }
-// CHECK: void P_with_assumes_call() __attribute__((assume("omp_no_openmp"))) __attribute__((assume("ompx_global_assumption"))) {
+// CHECK: void __attribute__((assume("omp_no_openmp"))) __attribute__((assume("ompx_global_assumption"))) P_with_assumes_call() {
 void P_with_assumes_call() {
   P<int> p;
   p.a = 0;
   // If this is executed we have UB!
   p.foo();
 }
 #pragma omp end assumes
 
 #endif

clang/test/OpenMP/declare_simd_ast_print.c

 // RUN: %clang_cc1 -verify -fopenmp -ast-print %s | FileCheck %s
 // RUN: %clang_cc1 -fopenmp -emit-pch -o %t %s
 // RUN: %clang_cc1 -fopenmp -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -ast-print %s | FileCheck %s
 // RUN: %clang_cc1 -fopenmp-simd -emit-pch -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
 // expected-no-diagnostics
 
 #ifndef HEADER
 #define HEADER
 
 #pragma omp declare simd aligned(b : 64)
 #pragma omp declare simd simdlen(32) aligned(d, b)
 #pragma omp declare simd inbranch, uniform(d) linear(val(s1, s2) : 32)
 #pragma omp declare simd notinbranch simdlen(2), uniform(s1, s2) linear(d: s1)
-void add_1(float *d, int s1, float *s2, double b[]) __attribute__((cold));
+void __attribute__((cold)) add_1(float *d, int s1, float *s2, double b[]);
 
 // CHECK: #pragma omp declare simd notinbranch simdlen(2) uniform(s1, s2) linear(val(d): s1){{$}}
 // CHECK-NEXT: #pragma omp declare simd inbranch uniform(d) linear(val(s1): 32) linear(val(s2): 32){{$}}
 // CHECK-NEXT: #pragma omp declare simd simdlen(32) aligned(d) aligned(b){{$}}
 // CHECK-NEXT: #pragma omp declare simd aligned(b: 64){{$}}
-// CHECK-NEXT: void add_1(float *d, int s1, float *s2, double b[]) __attribute__((cold))
+// CHECK-NEXT: void __attribute__((cold)) add_1(float *d, int s1, float *s2, double b[])
 
 #endif

clang/test/OpenMP/declare_simd_ast_print.cpp

 // RUN: %clang_cc1 -verify -fopenmp -x c++ -std=c++11 -ast-print %s | FileCheck %s
 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -emit-pch -o %t %s
 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -std=c++11 -ast-print %s | FileCheck %s
 // RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -emit-pch -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
 // expected-no-diagnostics
 
 #ifndef HEADER
 #define HEADER
 
 #pragma omp declare simd linear(d: 8)
 #pragma omp declare simd inbranch simdlen(32)
 #pragma omp declare simd notinbranch
-void add_1(float *d) __attribute__((cold));
+void __attribute__((cold)) add_1(float *d);
 
 // CHECK: #pragma omp declare simd notinbranch
 // CHECK-NEXT: #pragma omp declare simd inbranch simdlen(32)
 // CHECK-NEXT: #pragma omp declare simd linear(val(d): 8)
-// CHECK-NEXT: void add_1(float *d) __attribute__((cold));
+// CHECK-NEXT: void __attribute__((cold)) add_1(float *d);
 //
 
 #pragma omp declare simd aligned(hp, hp2:V)
 #pragma omp declare simd aligned(hp, hp2:V)
 template <class C, int V> void h(C *hp, C *hp2, C *hq, C *lin) {
 }
 // CHECK-NEXT: #pragma omp declare simd aligned(hp: V) aligned(hp2: V)
 // CHECK-NEXT: #pragma omp declare simd aligned(hp: V) aligned(hp2: V)
void h(int *hp, int *hp2, int *hq, int *lin)
   // Implicit specialization with <C=float>.
   // This is special case where the directive is stored by Sema and is
   // generated together with the (pending) function instatiation.
   h((float*) hp, (float*) hp2, (float*) hq, (float*) lin);
 }
 
 class VV {
   // CHECK: #pragma omp declare simd uniform(this, a) linear(val(b): a)
-  // CHECK-NEXT: int add(int a, int b) __attribute__((cold))    {
+  // CHECK-NEXT: int __attribute__((cold)) add(int a, int b)     {
   // CHECK-NEXT: return a + b;
   // CHECK-NEXT: }
   #pragma omp declare simd uniform(this, a) linear(val(b): a)
   int add(int a, int b) __attribute__((cold)) { return a + b; }
 
   // CHECK: #pragma omp declare simd aligned(b: 4) aligned(a) linear(ref(b): 4) linear(val(this)) linear(val(a))
   // CHECK-NEXT: float taddpf(float *a, float *&b)     {
   // CHECK-NEXT: return *a + *b;

clang/test/Sema/attr-print.c

 // RUN: %clang_cc1 %s -ast-print -fms-extensions | FileCheck %s
 
 // CHECK: int __attribute__((aligned(4))) x;
 int __attribute__((aligned(4))) x;
 
 // FIXME: Print this at a valid location for a __declspec attr.
 // CHECK: int __declspec(align(4)) y;
 int __declspec(align(4)) y;
 
 // CHECK: short __attribute__((aligned)) arr[3];
 short __attribute__((aligned)) arr[3];
 
-// CHECK: void foo(void) __attribute__((const));
+// CHECK: void __attribute__((const)) foo(void);
 void foo(void) __attribute__((const));
 
-// CHECK: void bar(void) __attribute__((__const));
+// CHECK: void __attribute__((__const)) bar(void);
 void bar(void) __attribute__((__const));
 
 // CHECK: int * __ptr32 p32;
 int * __ptr32 p32;
 
 // CHECK: int * __ptr64 p64;
 int * __ptr64 p64;
 
 // CHECK: int * __uptr __ptr32 p32_2;
 int * __uptr __ptr32 p32_2;
 
 // CHECK: int * __sptr __ptr64 p64_2;
 int * __sptr __ptr64 p64_2;
 
 // CHECK: int * __uptr __ptr32 p32_3;
 int * __uptr __ptr32 p32_3;
 
 // CHECK: int * __sptr * __ptr32 ppsp32;
 int * __sptr * __ptr32 ppsp32;
 
-// CHECK: __attribute__((availability(macos, strict, introduced=10.6)));
+// CHECK: void __attribute__((availability(macos, strict, introduced=10.6))) f6(int);
 void f6(int) __attribute__((availability(macosx,strict,introduced=10.6)));

clang/test/SemaCXX/attr-no-sanitize.cpp

 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
 // RUN: not %clang_cc1 -std=c++11 -ast-dump %s | FileCheck --check-prefix=DUMP %s
 // RUN: not %clang_cc1 -std=c++11 -ast-print %s | FileCheck --check-prefix=PRINT %s
 
 int f1() __attribute__((no_sanitize)); // expected-error{{'no_sanitize' attribute takes at least 1 argument}}
 
 int f2() __attribute__((no_sanitize(1))); // expected-error{{'no_sanitize' attribute requires a string}}
 
 __attribute__((no_sanitize("all"))) int global; // expected-warning{{'no_sanitize' attribute argument 'all' not supported on a global variable}}
 __attribute__((no_sanitize("unknown"))) int global2; // expected-warning{{unknown sanitizer 'unknown' ignored}}
 
 // DUMP-LABEL: FunctionDecl {{.*}} f3
 // DUMP: NoSanitizeAttr {{.*}} address
-// PRINT: int f3() __attribute__((no_sanitize("address")))
+// PRINT: int __attribute__((no_sanitize("address"))) f3()
 int f3() __attribute__((no_sanitize("address")));
 
 // DUMP-LABEL: FunctionDecl {{.*}} f4
 // DUMP: NoSanitizeAttr {{.*}} thread
 // PRINT: int f4() {{\[\[}}clang::no_sanitize("thread")]]
 [[clang::no_sanitize("thread")]] int f4();
 
 // DUMP-LABEL: FunctionDecl {{.*}} f4
 // DUMP: NoSanitizeAttr {{.*}} hwaddress
 // PRINT: int f4() {{\[\[}}clang::no_sanitize("hwaddress")]]
 [[clang::no_sanitize("hwaddress")]] int f4();
 
 // DUMP-LABEL: FunctionDecl {{.*}} f5
 // DUMP: NoSanitizeAttr {{.*}} address thread hwaddress
-// PRINT: int f5() __attribute__((no_sanitize("address", "thread", "hwaddress")))
+// PRINT: int __attribute__((no_sanitize("address", "thread", "hwaddress"))) f5()
 int f5() __attribute__((no_sanitize("address", "thread", "hwaddress")));
 
 // DUMP-LABEL: FunctionDecl {{.*}} f6
 // DUMP: NoSanitizeAttr {{.*}} unknown
-// PRINT: int f6() __attribute__((no_sanitize("unknown")))
+// PRINT: int __attribute__((no_sanitize("unknown"))) f6()
 int f6() __attribute__((no_sanitize("unknown"))); // expected-warning{{unknown sanitizer 'unknown' ignored}}
 
 // DUMP-LABEL: FunctionDecl {{.*}} f7
 // DUMP: NoSanitizeAttr {{.*}} memtag
 // PRINT: int f7() {{\[\[}}clang::no_sanitize("memtag")]]
 [[clang::no_sanitize("memtag")]] int f7();

clang/test/SemaCXX/attr-print.cpp

 // RUN: %clang_cc1 %s -ast-print -fms-extensions | FileCheck %s
 
 // CHECK: int __attribute__((aligned(4))) x;
 int __attribute__((aligned(4))) x;
 
 // FIXME: Print this at a valid location for a __declspec attr.
 // CHECK: int __declspec(align(4)) y;
 int __declspec(align(4)) y;
 
-// CHECK: void foo() __attribute__((const));
+// CHECK: void __attribute__((const)) foo();
 void foo() __attribute__((const));
 
-// CHECK: void bar() __attribute__((__const));
+// CHECK: void __attribute__((__const)) bar();
 void bar() __attribute__((__const));
 
 // FIXME: Print this with correct format.
-// CHECK: void foo1() __attribute__((noinline)) __attribute__((pure));
+// CHECK: void __attribute__((noinline)) __attribute__((pure)) foo1();
 void foo1() __attribute__((noinline, pure));
 
 // CHECK: typedef int Small1 __attribute__((mode(byte)));
 typedef int Small1 __attribute__((mode(byte)));
 
 // CHECK: int __attribute__((mode(byte))) small;
 int __attribute__((mode(byte))) small;
 
 // CHECK: int __attribute__((visibility("hidden"))) v;
 int __attribute__((visibility("hidden"))) v;
 
-// CHECK: char *PR24565() __attribute__((malloc))
+// CHECK: char *__attribute__((malloc)) PR24565()
 char *PR24565() __attribute__((__malloc__));
 
 // CHECK: class __attribute__((consumable("unknown"))) AttrTester1
 class __attribute__((consumable(unknown))) AttrTester1 {
-  // CHECK: void callableWhen() __attribute__((callable_when("unconsumed", "consumed")));
+  // CHECK: void __attribute__((callable_when("unconsumed", "consumed"))) callableWhen();
   void callableWhen()  __attribute__((callable_when("unconsumed", "consumed")));
 };
 
 // CHECK: class __single_inheritance SingleInheritance;
 class __single_inheritance SingleInheritance;
 
 // CHECK: class __multiple_inheritance MultipleInheritance;
 class __multiple_inheritance MultipleInheritance;
 
 // CHECK: class __virtual_inheritance VirtualInheritance;
 class __virtual_inheritance VirtualInheritance;
 
 // CHECK: typedef double *aligned_double __attribute__((align_value(64)));
 typedef double * __attribute__((align_value(64))) aligned_double;

clang/test/SemaCXX/cxx11-attr-print.cpp

 int __attribute__((deprecated("warning", "fixit"))) e;
 
 // CHECK: int cxx11_alignas alignas(4);
 alignas(4) int cxx11_alignas;
 
 // CHECK: int c11_alignas _Alignas(alignof(int));
 _Alignas(int) int c11_alignas;
 
-// CHECK: void foo() __attribute__((const));
+// CHECK: void __attribute__((const)) foo();
 void foo() __attribute__((const));
 
-// CHECK: void bar() __attribute__((__const));
-void bar() __attribute__((__const));
+// CHECK: void __attribute__((__const)) bar();
+void __attribute__((__const)) bar();
 
 // FIXME: It's unfortunate that the string literal prints with the below three
 // cases given that the string is only exposed via the [[nodiscard]] spelling.
-// CHECK: int f1() __attribute__((warn_unused_result("")));
-int f1() __attribute__((warn_unused_result));
+// CHECK: int __attribute__((warn_unused_result(""))) f1();
+int __attribute__((warn_unused_result)) f1();
 
 // CHECK: {{\[}}[clang::warn_unused_result("")]];
 int f2 [[clang::warn_unused_result]] ();
 
 // CHECK: {{\[}}[gnu::warn_unused_result("")]];
 int f3 [[gnu::warn_unused_result]] ();
 
 // FIXME: ast-print need to print C++11
 // attribute after function declare-id.
 // CHECK: {{\[}}[noreturn]];
 void f4 [[noreturn]] ();
 
-// CHECK: __attribute__((gnu_inline));
-inline void f6() __attribute__((gnu_inline));
+// CHECK: void __attribute__((gnu_inline))
+inline void __attribute__((gnu_inline)) f6();
 
 // CHECK: {{\[}}[gnu::gnu_inline]];
 inline void f7 [[gnu::gnu_inline]] ();
 
 // arguments printing
-// CHECK: __attribute__((format(printf, 2, 3)));
-void f8 (void *, const char *, ...) __attribute__ ((format (printf, 2, 3)));
+// CHECK: void __attribute__((format(printf, 2, 3)))
+void __attribute__ ((format (printf, 2, 3))) f8 (void *, const char *, ...);
 
 // CHECK: int m __attribute__((aligned(4)))
 // CHECK: int n alignas(4
-// CHECK: static int f() __attribute__((pure))
+// CHECK: static int __attribute__((pure)) f()
 // CHECK: static int g() {{\[}}[gnu::pure]]
 template <typename T> struct S {
   int __attribute__((aligned(4))) m;
   alignas(4) int n;
-  __attribute__((pure)) static int f() {
+  static int __attribute__((pure)) f() {
     return 0;
   }
   [[gnu::pure]] static int g() {
     return 1;
   }
 };
 
 // CHECK: int m __attribute__((aligned(4)))
 // CHECK: int n alignas(4
-// CHECK: static int f() __attribute__((pure))
+// CHECK: static int __attribute__((pure)) f()
 // CHECK: static int g() {{\[}}[gnu::pure]]
 template struct S<int>;
 
 // CHECK: using Small2 {{\[}}[gnu::mode(byte)]] = int;
 using Small2 [[gnu::mode(byte)]] = int;