[OpenMP] Fix trailing space when printing pragmas

[jdenny]

Summary

-ast-print prints omp pragmas with a trailing space. While this
behavior is likely of little concern to most users, surely it's
unintentional, and it's annoying for some source-level work I'm
pursuing. This patch focuses on omp pragmas, but it also fixes
init_seg and loop hint pragmas because they share implementation.

The testing strategy here is to add usually just one '{{$}}' per
relevant -ast-print test file. This seems to achieve good code
coverage. However, this strategy is probably easy to forget as the
tests evolve. That's probably fine as this fix is far from critical.
The main goal of the testing is to aid the initial review.

This patch also adds a fixme for "#pragma unroll", which prints as
"#pragma unroll (enable)", which is invalid syntax.

[ABataev]

LG

[jdenny]

In D43204#1007502, @ABataev wrote:

LG

Alexey: Thanks for accepting. I do not have commit privileges. Would
you please commit for me?

include/clang/Basic/Attr.td

 
 def InitSeg : Attr {
   let Spellings = [Pragma<"", "init_seg">];
   let Args = [StringArgument<"Section">];
   let SemaHandler = 0;
   let Documentation = [InitSegDocs];
   let AdditionalMembers = [{
   void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
-    OS << '(' << getSection() << ')';
+    OS << " (" << getSection() << ')';
   }
   }];
 }
 
 def LoopHint : Attr {
   /// #pragma clang loop <option> directive
   /// vectorize: vectorizes loop operations if State == Enable.
   /// vectorize_width: vectorize loop operations with width 'Value'.
def LoopHint : Attr {
 
   void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
     unsigned SpellingIndex = getSpellingListIndex();
     // For "#pragma unroll" and "#pragma nounroll" the string "unroll" or
     // "nounroll" is already emitted as the pragma name.
     if (SpellingIndex == Pragma_nounroll)
       return;
     else if (SpellingIndex == Pragma_unroll) {
-      OS << getValueString(Policy);
+      OS << ' ' << getValueString(Policy);
       return;
     }
 
     assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
-    OS << getOptionName(option) << getValueString(Policy);
+    OS << ' ' << getOptionName(option) << getValueString(Policy);
   }
 
   // Return a string containing the loop hint argument including the
   // enclosing parentheses.
   std::string getValueString(const PrintingPolicy &Policy) const {
     std::string ValueName;
     llvm::raw_string_ostream OS(ValueName);
     OS << "(";
let Args = [
     VariadicExprArgument<"Aligneds">, VariadicExprArgument<"Alignments">,
     VariadicExprArgument<"Linears">, VariadicUnsignedArgument<"Modifiers">,
     VariadicExprArgument<"Steps">
   ];
   let AdditionalMembers = [{
     void printPrettyPragma(raw_ostream & OS, const PrintingPolicy &Policy)
         const {
       if (getBranchState() != BS_Undefined)
-        OS << ConvertBranchStateTyToStr(getBranchState()) << " ";
+        OS << ' ' << ConvertBranchStateTyToStr(getBranchState());
       if (auto *E = getSimdlen()) {
-        OS << "simdlen(";
+        OS << " simdlen(";
         E->printPretty(OS, nullptr, Policy);
-        OS << ") ";
+        OS << ")";
       }
       if (uniforms_size() > 0) {
-        OS << "uniform";
+        OS << " uniform";
         StringRef Sep = "(";
         for (auto *E : uniforms()) {
           OS << Sep;
           E->printPretty(OS, nullptr, Policy);
           Sep = ", ";
         }
-        OS << ") ";
+        OS << ")";
       }
       alignments_iterator NI = alignments_begin();
       for (auto *E : aligneds()) {
-        OS << "aligned(";
+        OS << " aligned(";
         E->printPretty(OS, nullptr, Policy);
         if (*NI) {
           OS << ": ";
           (*NI)->printPretty(OS, nullptr, Policy);
         }
-        OS << ") ";
+        OS << ")";
         ++NI;
       }
       steps_iterator I = steps_begin();
       modifiers_iterator MI = modifiers_begin();
       for (auto *E : linears()) {
-        OS << "linear(";
+        OS << " linear(";
         if (*MI != OMPC_LINEAR_unknown)
           OS << getOpenMPSimpleClauseTypeName(OMPC_linear, *MI) << "(";
         E->printPretty(OS, nullptr, Policy);
         if (*MI != OMPC_LINEAR_unknown)
           OS << ")";
         if (*I) {
           OS << ": ";
           (*I)->printPretty(OS, nullptr, Policy);
         }
-        OS << ") ";
+        OS << ")";
         ++I;
         ++MI;
       }
     }
   }];
 }
 
 def OMPDeclareTargetDecl : Attr {
   let Spellings = [Pragma<"omp", "declare target">];
   let SemaHandler = 0;
   let Documentation = [OMPDeclareTargetDocs];
   let Args = [
     EnumArgument<"MapType", "MapTypeTy",
                  [ "to", "link" ],
                  [ "MT_To", "MT_Link" ]>
   ];
   let AdditionalMembers = [{
     void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
       // Use fake syntax because it is for testing and debugging purpose only.
       if (getMapType() != MT_To)
-        OS << ConvertMapTypeTyToStr(getMapType()) << " ";
+        OS << ' ' << ConvertMapTypeTyToStr(getMapType());
     }
   }];
 }
 
 def InternalLinkage : InheritableAttr {
   let Spellings = [Clang<"internal_linkage">];
   let Subjects = SubjectList<[Var, Function, CXXRecord]>;
   let Documentation = [InternalLinkageDocs];
 }

lib/AST/StmtPrinter.cpp

 
 void StmtPrinter::PrintOMPExecutableDirective(OMPExecutableDirective *S,
                                               bool ForceNoStmt) {
   OMPClausePrinter Printer(OS, Policy);
   ArrayRef<OMPClause *> Clauses = S->clauses();
   for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
        I != E; ++I)
     if (*I && !(*I)->isImplicit()) {
-      Printer.Visit(*I);
       OS << ' ';
+      Printer.Visit(*I);
     }
   OS << "\n";
   if (!ForceNoStmt && S->hasAssociatedStmt())
     PrintStmt(S->getInnermostCapturedStmt()->getCapturedStmt());
 }
 
 void StmtPrinter::VisitOMPParallelDirective(OMPParallelDirective *Node) {
-  Indent() << "#pragma omp parallel ";
+  Indent() << "#pragma omp parallel";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPSimdDirective(OMPSimdDirective *Node) {
-  Indent() << "#pragma omp simd ";
+  Indent() << "#pragma omp simd";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPForDirective(OMPForDirective *Node) {
-  Indent() << "#pragma omp for ";
+  Indent() << "#pragma omp for";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPForSimdDirective(OMPForSimdDirective *Node) {
-  Indent() << "#pragma omp for simd ";
+  Indent() << "#pragma omp for simd";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPSectionsDirective(OMPSectionsDirective *Node) {
-  Indent() << "#pragma omp sections ";
+  Indent() << "#pragma omp sections";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPSectionDirective(OMPSectionDirective *Node) {
   Indent() << "#pragma omp section";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPSingleDirective(OMPSingleDirective *Node) {
-  Indent() << "#pragma omp single ";
+  Indent() << "#pragma omp single";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPMasterDirective(OMPMasterDirective *Node) {
   Indent() << "#pragma omp master";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPCriticalDirective(OMPCriticalDirective *Node) {
   Indent() << "#pragma omp critical";
   if (Node->getDirectiveName().getName()) {
     OS << " (";
     Node->getDirectiveName().printName(OS);
     OS << ")";
   }
-  OS << " ";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPParallelForDirective(OMPParallelForDirective *Node) {
-  Indent() << "#pragma omp parallel for ";
+  Indent() << "#pragma omp parallel for";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPParallelForSimdDirective(
     OMPParallelForSimdDirective *Node) {
-  Indent() << "#pragma omp parallel for simd ";
+  Indent() << "#pragma omp parallel for simd";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPParallelSectionsDirective(
     OMPParallelSectionsDirective *Node) {
-  Indent() << "#pragma omp parallel sections ";
+  Indent() << "#pragma omp parallel sections";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTaskDirective(OMPTaskDirective *Node) {
-  Indent() << "#pragma omp task ";
+  Indent() << "#pragma omp task";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *Node) {
   Indent() << "#pragma omp taskyield";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPBarrierDirective(OMPBarrierDirective *Node) {
   Indent() << "#pragma omp barrier";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *Node) {
   Indent() << "#pragma omp taskwait";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *Node) {
-  Indent() << "#pragma omp taskgroup ";
+  Indent() << "#pragma omp taskgroup";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPFlushDirective(OMPFlushDirective *Node) {
-  Indent() << "#pragma omp flush ";
+  Indent() << "#pragma omp flush";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPOrderedDirective(OMPOrderedDirective *Node) {
-  Indent() << "#pragma omp ordered ";
+  Indent() << "#pragma omp ordered";
   PrintOMPExecutableDirective(Node, Node->hasClausesOfKind<OMPDependClause>());
 }
 
 void StmtPrinter::VisitOMPAtomicDirective(OMPAtomicDirective *Node) {
-  Indent() << "#pragma omp atomic ";
+  Indent() << "#pragma omp atomic";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTargetDirective(OMPTargetDirective *Node) {
-  Indent() << "#pragma omp target ";
+  Indent() << "#pragma omp target";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTargetDataDirective(OMPTargetDataDirective *Node) {
-  Indent() << "#pragma omp target data ";
+  Indent() << "#pragma omp target data";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTargetEnterDataDirective(
     OMPTargetEnterDataDirective *Node) {
-  Indent() << "#pragma omp target enter data ";
+  Indent() << "#pragma omp target enter data";
   PrintOMPExecutableDirective(Node, /*ForceNoStmt=*/true);
 }
 
 void StmtPrinter::VisitOMPTargetExitDataDirective(
     OMPTargetExitDataDirective *Node) {
-  Indent() << "#pragma omp target exit data ";
+  Indent() << "#pragma omp target exit data";
   PrintOMPExecutableDirective(Node, /*ForceNoStmt=*/true);
 }
 
 void StmtPrinter::VisitOMPTargetParallelDirective(
     OMPTargetParallelDirective *Node) {
-  Indent() << "#pragma omp target parallel ";
+  Indent() << "#pragma omp target parallel";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTargetParallelForDirective(
     OMPTargetParallelForDirective *Node) {
-  Indent() << "#pragma omp target parallel for ";
+  Indent() << "#pragma omp target parallel for";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTeamsDirective(OMPTeamsDirective *Node) {
-  Indent() << "#pragma omp teams ";
+  Indent() << "#pragma omp teams";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPCancellationPointDirective(
     OMPCancellationPointDirective *Node) {
   Indent() << "#pragma omp cancellation point "
            << getOpenMPDirectiveName(Node->getCancelRegion());
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPCancelDirective(OMPCancelDirective *Node) {
   Indent() << "#pragma omp cancel "
-           << getOpenMPDirectiveName(Node->getCancelRegion()) << " ";
+           << getOpenMPDirectiveName(Node->getCancelRegion());
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *Node) {
-  Indent() << "#pragma omp taskloop ";
+  Indent() << "#pragma omp taskloop";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTaskLoopSimdDirective(
     OMPTaskLoopSimdDirective *Node) {
-  Indent() << "#pragma omp taskloop simd ";
+  Indent() << "#pragma omp taskloop simd";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPDistributeDirective(OMPDistributeDirective *Node) {
-  Indent() << "#pragma omp distribute ";
+  Indent() << "#pragma omp distribute";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTargetUpdateDirective(
     OMPTargetUpdateDirective *Node) {
-  Indent() << "#pragma omp target update ";
+  Indent() << "#pragma omp target update";
   PrintOMPExecutableDirective(Node, /*ForceNoStmt=*/true);
 }
 
 void StmtPrinter::VisitOMPDistributeParallelForDirective(
     OMPDistributeParallelForDirective *Node) {
-  Indent() << "#pragma omp distribute parallel for ";
+  Indent() << "#pragma omp distribute parallel for";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPDistributeParallelForSimdDirective(
     OMPDistributeParallelForSimdDirective *Node) {
-  Indent() << "#pragma omp distribute parallel for simd ";
+  Indent() << "#pragma omp distribute parallel for simd";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPDistributeSimdDirective(
     OMPDistributeSimdDirective *Node) {
-  Indent() << "#pragma omp distribute simd ";
+  Indent() << "#pragma omp distribute simd";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTargetParallelForSimdDirective(
     OMPTargetParallelForSimdDirective *Node) {
-  Indent() << "#pragma omp target parallel for simd ";
+  Indent() << "#pragma omp target parallel for simd";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *Node) {
-  Indent() << "#pragma omp target simd ";
+  Indent() << "#pragma omp target simd";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTeamsDistributeDirective(
     OMPTeamsDistributeDirective *Node) {
-  Indent() << "#pragma omp teams distribute ";
+  Indent() << "#pragma omp teams distribute";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTeamsDistributeSimdDirective(
     OMPTeamsDistributeSimdDirective *Node) {
-  Indent() << "#pragma omp teams distribute simd ";
+  Indent() << "#pragma omp teams distribute simd";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTeamsDistributeParallelForSimdDirective(
     OMPTeamsDistributeParallelForSimdDirective *Node) {
-  Indent() << "#pragma omp teams distribute parallel for simd ";
+  Indent() << "#pragma omp teams distribute parallel for simd";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTeamsDistributeParallelForDirective(
     OMPTeamsDistributeParallelForDirective *Node) {
-  Indent() << "#pragma omp teams distribute parallel for ";
+  Indent() << "#pragma omp teams distribute parallel for";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *Node) {
-  Indent() << "#pragma omp target teams ";
+  Indent() << "#pragma omp target teams";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTargetTeamsDistributeDirective(
     OMPTargetTeamsDistributeDirective *Node) {
-  Indent() << "#pragma omp target teams distribute ";
+  Indent() << "#pragma omp target teams distribute";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTargetTeamsDistributeParallelForDirective(
     OMPTargetTeamsDistributeParallelForDirective *Node) {
-  Indent() << "#pragma omp target teams distribute parallel for ";
+  Indent() << "#pragma omp target teams distribute parallel for";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
     OMPTargetTeamsDistributeParallelForSimdDirective *Node) {
-  Indent() << "#pragma omp target teams distribute parallel for simd ";
+  Indent() << "#pragma omp target teams distribute parallel for simd";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPTargetTeamsDistributeSimdDirective(
     OMPTargetTeamsDistributeSimdDirective *Node) {
-  Indent() << "#pragma omp target teams distribute simd ";
+  Indent() << "#pragma omp target teams distribute simd";
   PrintOMPExecutableDirective(Node);
 }
 
 //===----------------------------------------------------------------------===//
 //  Expr printing methods.
 //===----------------------------------------------------------------------===//
 
 void StmtPrinter::VisitDeclRefExpr(DeclRefExpr *Node) {

test/Misc/ast-print-pragmas.cpp

 // RUN: %clang_cc1 -ast-print %s -o - | FileCheck %s
 // RUN: %clang_cc1 -DMS_EXT -fsyntax-only -fms-extensions %s -triple x86_64-pc-win32 -ast-print | FileCheck %s --check-prefix=MS-EXT
 
 // FIXME: A bug in ParsedAttributes causes the order of the attributes to be
 // reversed. The checks are consequently in the reverse order below.
 
-// CHECK: #pragma clang loop interleave_count(8)
+// CHECK: #pragma clang loop interleave_count(8){{$}}
 // CHECK-NEXT: #pragma clang loop vectorize_width(4)
 
 void test(int *List, int Length) {
   int i = 0;
 #pragma clang loop vectorize_width(4)
 #pragma clang loop interleave_count(8)
 // CHECK-NEXT: while (i < Length)
   while (i < Length) {

 // CHECK: #pragma clang loop vectorize_width(V)
 
 void test_templates(int *List, int Length) {
   test_nontype_template_param<2, 4>(List, Length);
 }
 
 #ifdef MS_EXT
 #pragma init_seg(compiler)
-// MS-EXT: #pragma init_seg (.CRT$XCC)
+// MS-EXT: #pragma init_seg (.CRT$XCC){{$}}
 // MS-EXT-NEXT: int x = 3 __declspec(thread);
 int __declspec(thread) x = 3;
 #endif //MS_EXT
 

test/OpenMP/atomic_ast_print.cpp

#pragma omp atomic capture seq_cst
   {
     a = b;
     b++;
   }
   return T();
 }
 
 // CHECK: T a = T();
-// CHECK-NEXT: #pragma omp atomic
+// CHECK-NEXT: #pragma omp atomic{{$}}
 // CHECK-NEXT: a++;
 // CHECK-NEXT: #pragma omp atomic read
 // CHECK-NEXT: a = argc;
 // CHECK-NEXT: #pragma omp atomic write
 // CHECK-NEXT: a = argc + argc;
 // CHECK-NEXT: #pragma omp atomic update
 // CHECK-NEXT: a = a + argc;
 // CHECK-NEXT: #pragma omp atomic capture

test/OpenMP/barrier_ast_print.cpp

#pragma omp barrier
   default:
 #pragma omp barrier
 #pragma omp barrier
     break;
   }
   return a + argc;
 }
 // CHECK:      static T a;
-// CHECK-NEXT: #pragma omp barrier
+// CHECK-NEXT: #pragma omp barrier{{$}}
 // CHECK:      static int a;
 // CHECK-NEXT: #pragma omp barrier
 // CHECK:      static char a;
 // CHECK-NEXT: #pragma omp barrier
 // CHECK-NEXT: switch (argc) {
 // CHECK-NEXT: case 0:
 // CHECK-NEXT: #pragma omp barrier
 // CHECK-NEXT: break;

test/OpenMP/cancel_ast_print.cpp

 // CHECK-NEXT: #pragma omp cancel parallel if(argc)
 // CHECK-NEXT: }
 #pragma omp sections
 {
 #pragma omp cancel sections
 }
 // CHECK-NEXT: #pragma omp sections
 // CHECK: {
-// CHECK: #pragma omp cancel sections
+// CHECK: #pragma omp cancel sections{{$}}
 // CHECK: }
 #pragma omp for
 for (int i = 0; i < argc; ++i) {
 #pragma omp cancel for if(cancel:argc)
 }
 // CHECK: #pragma omp for
 // CHECK-NEXT: for (int i = 0; i < argc; ++i) {
 // CHECK-NEXT: #pragma omp cancel for if(cancel: argc)

test/OpenMP/cancellation_point_ast_print.cpp

 int main (int argc, char **argv) {
 // CHECK: int main(int argc, char **argv) {
 #pragma omp parallel
 {
 #pragma omp cancellation point parallel
 }
 // CHECK: #pragma omp parallel
 // CHECK-NEXT: {
-// CHECK-NEXT: #pragma omp cancellation point parallel
+// CHECK-NEXT: #pragma omp cancellation point parallel{{$}}
 // CHECK-NEXT: }
 #pragma omp sections
 {
 #pragma omp cancellation point sections
 }
 // CHECK-NEXT: #pragma omp sections
 // CHECK: {
 // CHECK: #pragma omp cancellation point sections

test/OpenMP/critical_ast_print.cpp

 // RUN: %clang_cc1 -verify -fopenmp -ast-print %s | FileCheck %s
 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -emit-pch -o %t %s
 // RUN: %clang_cc1 -fopenmp -std=c++11 -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 -x c++ -std=c++11 -emit-pch -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
 // expected-no-diagnostics
 
 #ifndef HEADER
 #define HEADER
 
 void foo() {}
 
 // CHECK: template <typename T, int N> int tmain(T argc, char **argv)
 // CHECK: static int a;
-// CHECK-NEXT: #pragma omp critical
+// CHECK-NEXT: #pragma omp critical{{$}}
 // CHECK-NEXT: a = 2;
 // CHECK-NEXT: ++a;
-// CHECK-NEXT: #pragma omp critical (the_name) hint(N)
+// CHECK-NEXT: #pragma omp critical (the_name) hint(N){{$}}
 // CHECK-NEXT: foo();
 // CHECK-NEXT: return N;
 // CHECK: template<> int tmain<int, 4>(int argc, char **argv)
 template <typename T, int N>
 int tmain (T argc, char **argv) {
   T b = argc, c, d, e, f, g;
   static int a;
 // CHECK: static int a;

test/OpenMP/declare_reduction_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 reduction(+ : int, char : omp_out *= omp_in)
-// CHECK: #pragma omp declare reduction (+ : int : omp_out *= omp_in)
+// CHECK: #pragma omp declare reduction (+ : int : omp_out *= omp_in){{$}}
 // CHECK-NEXT: #pragma omp declare reduction (+ : char : omp_out *= omp_in)
 
 #pragma omp declare reduction(fun : float : omp_out += omp_in) initializer(omp_priv = omp_orig + 15)
 // CHECK: #pragma omp declare reduction (fun : float : omp_out += omp_in) initializer(omp_priv = omp_orig + 15)
 
 // CHECK: struct SSS {
 struct SSS {
   int field;

test/OpenMP/declare_reduction_ast_print.cpp

 // RUN: %clang_cc1 -verify -fopenmp -ast-print %s | FileCheck %s
 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -emit-pch -o %t %s
 // RUN: %clang_cc1 -fopenmp -std=c++11 -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 -x c++ -std=c++11 -emit-pch -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
 // expected-no-diagnostics
 
 #ifndef HEADER
 #define HEADER
 
 #pragma omp declare reduction(+ : int, char : omp_out *= omp_in)
-// CHECK: #pragma omp declare reduction (+ : int : omp_out *= omp_in)
+// CHECK: #pragma omp declare reduction (+ : int : omp_out *= omp_in){{$}}
 // CHECK-NEXT: #pragma omp declare reduction (+ : char : omp_out *= omp_in)
 
 template <class T>
 class SSS {
 public:
 #pragma omp declare reduction(fun : T : omp_out += omp_in) initializer(omp_priv = omp_orig + 15)
   // CHECK: #pragma omp declare reduction (fun : T : omp_out += omp_in) initializer(omp_priv = omp_orig + 15)
   // CHECK: #pragma omp declare reduction (fun : int : omp_out += omp_in) initializer(omp_priv = omp_orig + 15)

test/OpenMP/declare_simd_ast_print.c

 #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));
 
-// 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: #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))
 
 #endif

test/OpenMP/declare_simd_ast_print.cpp

 
 // CHECK: template <int X, typename T> class TVV {
 // CHECK: #pragma omp declare simd simdlen(X)
 // CHECK-NEXT: int tadd(int a, int b) {
 // CHECK: #pragma omp declare simd aligned(a: X * 2) aligned(b) linear(ref(b): X)
 // CHECK-NEXT: float taddpf(float *a, T *&b) {
 // CHECK-NEXT: return *a + *b;
 // CHECK-NEXT: }
-// CHECK: #pragma omp declare simd
-// CHECK-NEXT: #pragma omp declare simd
+// CHECK: #pragma omp declare simd uniform(this, b)
+// CHECK-NEXT: #pragma omp declare simd{{$}}
 // CHECK-NEXT: int tadd(int b) {
 // CHECK-NEXT: return this->x[b] + b;
 // CHECK-NEXT: }
 // CHECK: }
 template <int X, typename T>
 class TVV {
 public:
 // CHECK: template<> class TVV<16, float> {

test/OpenMP/declare_target_ast_print.cpp

 // RUN: %clang_cc1 -verify -fopenmp -ast-print %s | FileCheck %s
 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -emit-pch -o %t %s
 // RUN: %clang_cc1 -fopenmp -std=c++11 -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 -x c++ -std=c++11 -emit-pch -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
 // expected-no-diagnostics
 
 #ifndef HEADER
 #define HEADER
 
 #pragma omp declare target
-// CHECK: #pragma omp declare target
+// CHECK: #pragma omp declare target{{$}}
 void foo() {}
 // CHECK-NEXT: void foo()
 #pragma omp end declare target
-// CHECK: #pragma omp end declare target
+// CHECK: #pragma omp end declare target{{$}}
 
 extern "C" {
 #pragma omp declare target
 // CHECK: #pragma omp declare target
 void foo_c() {}
 // CHECK-NEXT: void foo_c()
 #pragma omp end declare target
 // CHECK: #pragma omp end declare target

 }
 #pragma omp end declare target
 // CHECK: #pragma omp end declare target
 
 int a1;
 void f1() {
 }
 #pragma omp declare target (a1, f1)
-// CHECK: #pragma omp declare target
+// CHECK: #pragma omp declare target{{$}}
 // CHECK: int a1;
-// CHECK: #pragma omp end declare target
-// CHECK: #pragma omp declare target
+// CHECK: #pragma omp end declare target{{$}}
+// CHECK: #pragma omp declare target{{$}}
 // CHECK: void f1()
-// CHECK: #pragma omp end declare target
+// CHECK: #pragma omp end declare target{{$}}
 
 int b1, b2, b3;
 void f2() {
 }
 #pragma omp declare target to(b1) to(b2), to(b3, f2)
-// CHECK: #pragma omp declare target
+// CHECK: #pragma omp declare target{{$}}
 // CHECK: int b1;
-// CHECK: #pragma omp end declare target
-// CHECK: #pragma omp declare target
+// CHECK: #pragma omp end declare target{{$}}
+// CHECK: #pragma omp declare target{{$}}
 // CHECK: int b2;
-// CHECK: #pragma omp end declare target
-// CHECK: #pragma omp declare target
+// CHECK: #pragma omp end declare target{{$}}
+// CHECK: #pragma omp declare target{{$}}
 // CHECK: int b3;
-// CHECK: #pragma omp end declare target
-// CHECK: #pragma omp declare target
+// CHECK: #pragma omp end declare target{{$}}
+// CHECK: #pragma omp declare target{{$}}
 // CHECK: void f2()
-// CHECK: #pragma omp end declare target
+// CHECK: #pragma omp end declare target{{$}}
 
 int c1, c2, c3;
 #pragma omp declare target link(c1) link(c2), link(c3)
-// CHECK: #pragma omp declare target link
+// CHECK: #pragma omp declare target link{{$}}
 // CHECK: int c1;
-// CHECK: #pragma omp end declare target
-// CHECK: #pragma omp declare target link
+// CHECK: #pragma omp end declare target{{$}}
+// CHECK: #pragma omp declare target link{{$}}
 // CHECK: int c2;
-// CHECK: #pragma omp end declare target
-// CHECK: #pragma omp declare target link
+// CHECK: #pragma omp end declare target{{$}}
+// CHECK: #pragma omp declare target link{{$}}
 // CHECK: int c3;
-// CHECK: #pragma omp end declare target
+// CHECK: #pragma omp end declare target{{$}}
 
 struct SSSt {
 #pragma omp declare target
   static int a;
   int b;
 #pragma omp end declare target
 };
 

test/OpenMP/distribute_ast_print.cpp

 // CHECK-NEXT: #pragma omp distribute private(this->a) private(this->a)
 
 template <class T, int N>
 T tmain(T argc) {
   T b = argc, c, d, e, f, g;
   static T a;
 // CHECK: static T a;
 #pragma omp distribute
-// CHECK-NEXT: #pragma omp distribute
+// CHECK-NEXT: #pragma omp distribute{{$}}
   for (int i=0; i < 2; ++i)a=2;
 // CHECK-NEXT: for (int i = 0; i < 2; ++i)
 // CHECK-NEXT: a = 2;
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute private(argc, b), firstprivate(c, d), collapse(2)
   for (int i = 0; i < 10; ++i)
   for (int j = 0; j < 10; ++j)foo();

test/OpenMP/distribute_dist_schedule_ast_print.cpp

 void foo() {}
 
 template <class T, int N>
 T tmain(T argc) {
   T b = argc, c, d, e, f, g;
   static T a;
 // CHECK: static T a;
 #pragma omp distribute dist_schedule(static,10)
-// CHECK-NEXT: #pragma omp distribute dist_schedule(static, 10)
+// CHECK-NEXT: #pragma omp distribute dist_schedule(static, 10){{$}}
   for (int i=0; i < 2; ++i)a=2;
 // CHECK-NEXT: for (int i = 0; i < 2; ++i)
 // CHECK-NEXT: a = 2;
 #pragma omp distribute dist_schedule(static,a)
 // CHECK-NEXT: #pragma omp distribute dist_schedule(static, a)
   for (int i=0; i < 2; ++i)a=2;
 // CHECK-NEXT: for (int i = 0; i < 2; ++i)
 // CHECK-NEXT: a = 2;

test/OpenMP/distribute_parallel_for_ast_print.cpp

 #pragma omp teams
 #pragma omp distribute parallel for private(a) private(this->a)
     for (int k = 0; k < s.a.a; ++k)
       ++s.a.a;
     return *this;
   }
 };
 
-// CHECK: #pragma omp distribute parallel for private(this->a) private(this->a) private(T::a)
+// CHECK: #pragma omp distribute parallel for private(this->a) private(this->a) private(T::a){{$}}
 // CHECK: #pragma omp distribute parallel for private(this->a) private(this->a)
 // CHECK: #pragma omp distribute parallel for private(this->a) private(this->a) private(this->S::a)
 
 class S8 : public S7<S> {
   S8() {}
 
 public:
   S8(int v) : S7<S>(v){

test/OpenMP/distribute_parallel_for_simd_ast_print.cpp

 #pragma omp teams
 #pragma omp distribute parallel for simd private(a) private(this->a) linear(k)
     for (k = 0; k < s.a.a; ++k)
       ++s.a.a;
     return *this;
   }
 };
 
-// CHECK: #pragma omp distribute parallel for simd private(this->a) private(this->a) private(T::a)
+// CHECK: #pragma omp distribute parallel for simd private(this->a) private(this->a) private(T::a){{$}}
 // CHECK: #pragma omp distribute parallel for simd private(this->a) private(this->a) linear(k)
 // CHECK: #pragma omp distribute parallel for simd private(this->a) private(this->a) private(this->S::a)
 
 class S8 : public S7<S> {
   S8() {}
 
 public:
   S8(int v) : S7<S>(v){

test/OpenMP/distribute_simd_ast_print.cpp

 #pragma omp teams
 #pragma omp distribute simd private(a) private(this->a)
     for (int k = 0; k < s.a.a; ++k)
       ++s.a.a;
     return *this;
   }
 };
 
-// CHECK: #pragma omp distribute simd private(this->a) private(this->a) private(T::a)
+// CHECK: #pragma omp distribute simd private(this->a) private(this->a) private(T::a){{$}}
 // CHECK: #pragma omp distribute simd private(this->a) private(this->a)
 // CHECK: #pragma omp distribute simd private(this->a) private(this->a) private(this->S::a)
 
 class S8 : public S7<S> {
   S8() {}
 
 public:
   S8(int v) : S7<S>(v){

test/OpenMP/flush_ast_print.cpp

 template <class T>
 T tmain(T argc) {
   static T a;
 #pragma omp flush
 #pragma omp flush(a)
   return a + argc;
 }
 // CHECK:      static T a;
-// CHECK-NEXT: #pragma omp flush
+// CHECK-NEXT: #pragma omp flush{{$}}
 // CHECK-NEXT: #pragma omp flush (a)
 // CHECK:      static int a;
 // CHECK-NEXT: #pragma omp flush
 // CHECK-NEXT: #pragma omp flush (a)
 // CHECK:      static char a;
 // CHECK-NEXT: #pragma omp flush
 // CHECK-NEXT: #pragma omp flush (a)
 

test/OpenMP/for_ast_print.cpp

#pragma omp for private(argc, b), firstprivate(argv, c), lastprivate(d, f) collapse(2) schedule(auto) ordered nowait linear(g:-1)
   char buf[9] = "01234567";
   char *p, *q;
 #pragma omp parallel
 #pragma omp for
   for (p = buf; p < &buf[8]; p++)
     for (q = &buf[0]; q <= buf + 7; q++)
       foo();
   // CHECK: #pragma omp parallel
-  // CHECK-NEXT: #pragma omp for
+  // CHECK-NEXT: #pragma omp for{{$}}
   // CHECK-NEXT: for (p = buf; p < &buf[8]; p++)
   // CHECK-NEXT: for (q = &buf[0]; q <= buf + 7; q++)
   // CHECK-NEXT: foo();
   return (tmain<int, 5>(argc) + tmain<char, 1>(argv[0][0]));
 }
 
 #endif

test/OpenMP/for_simd_ast_print.cpp

#pragma omp for simd private(a) private(this->a) private(T::a)
   S7 &operator=(S7 &s) {
 #pragma omp for simd private(a) private(this->a)
     for (int k = 0; k < s.a.a; ++k)
       ++s.a.a;
     return *this;
   }
 };
 
-// CHECK: #pragma omp for simd private(this->a) private(this->a) private(T::a)
+// CHECK: #pragma omp for simd private(this->a) private(this->a) private(T::a){{$}}
 // CHECK: #pragma omp for simd private(this->a) private(this->a)
 // CHECK: #pragma omp for simd private(this->a) private(this->a) private(this->S1::a)
 
 class S8 : public S7<S1> {
   S8() {}
 
 public:
   S8(int v) : S7<S1>(v){

test/OpenMP/master_ast_print.cpp

 {
 #pragma omp master
 {
   a=2;
 }
 }
 // CHECK-NEXT: #pragma omp parallel
 // CHECK-NEXT: {
-// CHECK-NEXT: #pragma omp master
+// CHECK-NEXT: #pragma omp master{{$}}
 // CHECK-NEXT: {
 // CHECK-NEXT: a = 2;
 // CHECK-NEXT: }
 // CHECK-NEXT: }
   return (0);
 }
 
 #endif

test/OpenMP/ordered_ast_print.cpp

#pragma omp ordered depend(sink:i+N)
     a = 2;
   }
   return (0);
 }
 
 // CHECK: static T a;
 // CHECK-NEXT: #pragma omp for ordered
 // CHECK-NEXT: for (int i = 0; i < argc; ++i)
-// CHECK-NEXT: #pragma omp ordered
+// CHECK-NEXT: #pragma omp ordered{{$}}
 // CHECK-NEXT: {
 // CHECK-NEXT: a = 2;
 // CHECK-NEXT: }
 // CHECK-NEXT: #pragma omp for ordered
 // CHECK-NEXT: for (int i = 0; i < argc; ++i)
 // CHECK-NEXT: #pragma omp ordered threads
 // CHECK-NEXT: {
 // CHECK-NEXT: a = 2;

test/OpenMP/parallel_ast_print.cpp

#pragma omp parallel if (C) num_threads(s) proc_bind(close) reduction(^:e, f, arr[0:C][:argc]) reduction(&& : g)
   return 0;
 }
 
 // CHECK: template <typename T, int C> T tmain(T argc, T *argv) {
 // CHECK-NEXT: T b = argc, c, d, e, f, g;
 // CHECK-NEXT: static T a;
 // CHECK-NEXT: S<T> s;
 // CHECK-NEXT: T arr[C][10], arr1[C];
-// CHECK-NEXT: #pragma omp parallel
+// CHECK-NEXT: #pragma omp parallel{{$}}
 // CHECK-NEXT: a = 2;
 // CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(C) copyin(S<T>::TS,thrp) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: e,arr[:C][0:10])
 // CHECK-NEXT: foo()
 // CHECK-NEXT: #pragma omp parallel if(C) num_threads(s) proc_bind(close) reduction(^: e,f,arr[0:C][:argc]) reduction(&&: g)
 // CHECK-NEXT: foo()
 // CHECK: template<> int tmain<int, 5>(int argc, int *argv) {
 // CHECK-NEXT: int b = argc, c, d, e, f, g;
 // CHECK-NEXT: static int a;

test/OpenMP/parallel_for_ast_print.cpp

#pragma omp parallel for private(a) private(this->a) private(T::a)
   S7 &operator=(S7 &s) {
 #pragma omp parallel for private(a) private(this->a)
     for (int k = 0; k < s.a.a; ++k)
       ++s.a.a;
     return *this;
   }
 };
 
-// CHECK: #pragma omp parallel for private(this->a) private(this->a) private(T::a)
+// CHECK: #pragma omp parallel for private(this->a) private(this->a) private(T::a){{$}}
 // CHECK: #pragma omp parallel for private(this->a) private(this->a)
 // CHECK: #pragma omp parallel for private(this->a) private(this->a) private(this->S::a)
 
 class S8 : public S7<S> {
   S8() {}
 
 public:
   S8(int v) : S7<S>(v){

test/OpenMP/parallel_for_simd_ast_print.cpp

#pragma omp parallel for simd private(a) private(this->a) private(T::a)
   S7 &operator=(S7 &s) {
 #pragma omp parallel for simd private(a) private(this->a)
     for (int k = 0; k < s.a.a; ++k)
       ++s.a.a;
     return *this;
   }
 };
 
-// CHECK: #pragma omp parallel for simd private(this->a) private(this->a) private(T::a)
+// CHECK: #pragma omp parallel for simd private(this->a) private(this->a) private(T::a){{$}}
 // CHECK: #pragma omp parallel for simd private(this->a) private(this->a)
 // CHECK: #pragma omp parallel for simd private(this->a) private(this->a) private(this->S1::a)
 
 class S8 : public S7<S1> {
   S8() {}
 
 public:
   S8(int v) : S7<S1>(v){

test/OpenMP/parallel_sections_ast_print.cpp

#pragma omp section
   }
   return 0;
 }
 
 // CHECK: template <typename T, int C> T tmain(T argc, T *argv) {
 // CHECK-NEXT: T b = argc, c, d, e, f, g;
 // CHECK-NEXT: static T a;
 // CHECK-NEXT: S<T> s;
-// CHECK-NEXT: #pragma omp parallel sections
+// CHECK-NEXT: #pragma omp parallel sections{{$}}
 // CHECK-NEXT: {
 // CHECK-NEXT: a = 2;
 // CHECK-NEXT: }
 // CHECK-NEXT: #pragma omp parallel sections default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(C) copyin(S<T>::TS) proc_bind(master) reduction(+: c) reduction(max: e)
 // CHECK-NEXT: {
 // CHECK-NEXT: foo();
 // CHECK-NEXT: }
 // CHECK-NEXT: #pragma omp parallel sections if(C) num_threads(s) proc_bind(close) reduction(^: e,f) reduction(&&: g) lastprivate(b,c)

test/OpenMP/sections_ast_print.cpp

T tmain(T argc) {
   static T a;
 // CHECK: static T a;
 #pragma omp parallel
 #pragma omp sections private(argc, b), firstprivate(c, d), lastprivate(d, f) reduction(- : g) nowait
   {
     foo();
   }
   // CHECK-NEXT: #pragma omp parallel
-  // CHECK-NEXT: #pragma omp sections private(argc,b) firstprivate(c,d) lastprivate(d,f) reduction(-: g) nowait
+  // CHECK-NEXT: #pragma omp sections private(argc,b) firstprivate(c,d) lastprivate(d,f) reduction(-: g) nowait{{$}}
   // CHECK-NEXT: {
   // CHECK-NEXT: foo();
   // CHECK-NEXT: }
   return T();
 }
 
 int main(int argc, char **argv) {
 // CHECK: int main(int argc, char **argv) {
   int b = argc, c, d, e, f, g;
   static int a;
 // CHECK: static int a;
 #pragma omp parallel
 #pragma omp sections private(argc, b), firstprivate(argv, c), lastprivate(d, f) reduction(+ : g) nowait
   {
 #pragma omp section
     foo();
 #pragma omp section
     foo();
   }
   // CHECK-NEXT: #pragma omp parallel
   // CHECK-NEXT: #pragma omp sections private(argc,b) firstprivate(argv,c) lastprivate(d,f) reduction(+: g) nowait
   // CHECK-NEXT: {
-  // CHECK-NEXT: #pragma omp section
+  // CHECK-NEXT: #pragma omp section{{$}}
   // CHECK-NEXT: foo();
   // CHECK-NEXT: #pragma omp section
   // CHECK-NEXT: foo();
   // CHECK-NEXT: }
   return (tmain<int, 5>(argc) + tmain<char, 1>(argv[0][0]));
 }
 
 #endif

test/OpenMP/simd_ast_print.cpp

#pragma omp simd aligned(a)
   S7 &operator=(S7 &s) {
 #pragma omp simd aligned(this->b : 8)
     for (int k = 0; k < s.a->a; ++k)
       ++s.a->a;
     return *this;
   }
 };
 
-// CHECK: #pragma omp simd aligned(this->a)
+// CHECK: #pragma omp simd aligned(this->a){{$}}
 // CHECK: #pragma omp simd aligned(this->b: 8)
 // CHECK: #pragma omp simd aligned(this->a)
 
 class S8 : public S7<SS> {
   S8() {}
 
 public:
   S8(int v) : S7<SS>(v){

 
 int main (int argc, char **argv) {
   int b = argc, c, d, e, f, g;
   int k1=0,k2=0;
   int &ref = b;
   static int *a;
 // CHECK: static int *a;
 #pragma omp simd
-// CHECK-NEXT: #pragma omp simd
+// CHECK-NEXT: #pragma omp simd{{$}}
   for (int i=0; i < 2; ++i)*a=2;
 // CHECK-NEXT: for (int i = 0; i < 2; ++i)
 // CHECK-NEXT: *a = 2;
 #pragma omp simd private(argc, b),lastprivate(d,f) collapse(2) aligned(a : 4)
   for (int i = 0; i < 10; ++i)
   for (int j = 0; j < 10; ++j) {foo(); k1 += 8; k2 += 8;}
 // CHECK-NEXT: #pragma omp simd private(argc,b) lastprivate(d,f) collapse(2) aligned(a: 4)
 // CHECK-NEXT: for (int i = 0; i < 10; ++i)

test/OpenMP/single_ast_print.cpp

 struct SS {
   int a;
   int b : 4;
   int &c;
   SS(int &d) : a(0), b(0), c(d) {
 #pragma omp parallel firstprivate(a, b, c)
 #pragma omp single copyprivate(a, this->b, (this)->c)
 // CHECK: #pragma omp parallel firstprivate(this->a,this->b,this->c)
-// CHECK-NEXT: #pragma omp single copyprivate(this->a,this->b,this->c)
+// CHECK-NEXT: #pragma omp single copyprivate(this->a,this->b,this->c){{$}}
     ++this->a, --b, (this)->c /= 1;
   }
 };
 
 template<typename T>
 struct SST {
   T a;
   SST() : a(T()) {

test/OpenMP/target_ast_print.cpp

#pragma omp target depend(in : argc, argv[i:argc], a[:])
   foo();
 #pragma omp target defaultmap(tofrom: scalar)
   foo();
   return 0;
 }
 
 // CHECK: template <typename T, int C> T tmain(T argc, T *argv) {
 // CHECK-NEXT: T i, j, a[20]
-// CHECK-NEXT: #pragma omp target
+// CHECK-NEXT: #pragma omp target{{$}}
 // CHECK-NEXT: foo();
 // CHECK-NEXT: #pragma omp target if(target: argc > 0)
 // CHECK-NEXT: foo()
 // CHECK-NEXT: #pragma omp target if(C)
 // CHECK-NEXT: foo()
 // CHECK-NEXT: #pragma omp target map(tofrom: i)
 // CHECK-NEXT: foo()
 // CHECK-NEXT: #pragma omp target map(tofrom: a[0:10],i)

test/OpenMP/target_data_ast_print.cpp

#pragma omp target map(always, alloc: e)
     foo();
 }
 
   return 0;
 }
 
 // CHECK: template <typename T, int C> T tmain(T argc, T *argv) {
 // CHECK-NEXT: T i, j, b, c, d, e, x[20];
-// CHECK-NEXT: #pragma omp target data map(to: c)
+// CHECK-NEXT: #pragma omp target data map(to: c){{$}}
 // CHECK-NEXT: i = argc;
 // CHECK-NEXT: #pragma omp target data map(to: c) if(target data: j > 0)
 // CHECK-NEXT: foo();
 // CHECK-NEXT: #pragma omp target data map(to: c) if(b)
 // CHECK-NEXT: foo();
 // CHECK-NEXT: #pragma omp target data map(tofrom: c)
 // CHECK-NEXT: foo();
 // CHECK-NEXT: #pragma omp target data map(tofrom: c) if(b > e)

test/OpenMP/target_data_use_device_ptr_ast_print.cpp

#pragma omp target data map(tofrom: i) use_device_ptr(k)
     {}
 #pragma omp target data map(tofrom: i) use_device_ptr(z)
     {}
   return;
  }
 };
 // CHECK: struct SA
 // CHECK: void func(
-// CHECK: #pragma omp target data map(tofrom: this->i) use_device_ptr(this->k)
+// CHECK: #pragma omp target data map(tofrom: this->i) use_device_ptr(this->k){{$}}
 // CHECK: #pragma omp target data map(tofrom: this->i) use_device_ptr(this->z)
 struct SB {
   unsigned A;
   unsigned B;
   float Arr[100];
   float *Ptr;
   float *foo() {
     return &Arr[0];

test/OpenMP/target_enter_data_ast_print.cpp

 #pragma omp target enter data nowait map(always,alloc: e) depend(in : argc, argv[i:argc], x[:])
 
   return 0;
 }
 
 // CHECK: template <typename T, int C> T tmain(T argc, T *argv) {
 // CHECK-NEXT: T i, j, b, c, d, e, x[20];
 // CHECK-NEXT: i = argc;
-// CHECK-NEXT: #pragma omp target enter data map(to: i)
+// CHECK-NEXT: #pragma omp target enter data map(to: i){{$}}
 // CHECK-NEXT: #pragma omp target enter data map(to: i) if(target enter data: j > 0)
 // CHECK-NEXT: #pragma omp target enter data map(to: i) if(b)
 // CHECK-NEXT: #pragma omp target enter data map(to: c)
 // CHECK-NEXT: #pragma omp target enter data map(to: c) if(b > e)
 // CHECK-NEXT: #pragma omp target enter data map(alloc: x[0:10],c)
 // CHECK-NEXT: #pragma omp target enter data map(to: c) map(alloc: d)
 // CHECK-NEXT: #pragma omp target enter data map(always,alloc: e)
 // CHECK-NEXT: #pragma omp target enter data nowait map(to: i)

test/OpenMP/target_exit_data_ast_print.cpp

 #pragma omp target exit data depend(in : argc, argv[i:argc], x[:]) nowait map(always,release: e)
 
   return 0;
 }
 
 // CHECK: template <typename T, int C> T tmain(T argc, T *argv) {
 // CHECK-NEXT: T i, j, b, c, d, e, x[20];
 // CHECK-NEXT: i = argc;
-// CHECK-NEXT: #pragma omp target exit data map(from: i)
+// CHECK-NEXT: #pragma omp target exit data map(from: i){{$}}
 // CHECK-NEXT: #pragma omp target exit data map(from: i) if(target exit data: j > 0)
 // CHECK-NEXT: #pragma omp target exit data map(from: i) if(b)
 // CHECK-NEXT: #pragma omp target exit data map(from: c)
 // CHECK-NEXT: #pragma omp target exit data map(from: c) if(b > e)
 // CHECK-NEXT: #pragma omp target exit data map(release: x[0:10],c)
 // CHECK-NEXT: #pragma omp target exit data map(delete: x[0:10])
 // CHECK-NEXT: #pragma omp target exit data map(always,delete: x[0:10])
 // CHECK-NEXT: #pragma omp target exit data map(from: c) map(release: d)

test/OpenMP/target_is_device_ptr_ast_print.cpp

 // CHECK-NEXT: STarr &rg = this->g;
 // CHECK-NEXT: int i;
 // CHECK-NEXT: int &j = this->i;
 // CHECK-NEXT: int *k = &this->j;
 // CHECK-NEXT: int *&z = this->k;
 // CHECK-NEXT: int aa[10];
 // CHECK-NEXT: arr &raa = this->aa;
 // CHECK-NEXT: func(
-// CHECK-NEXT: #pragma omp target is_device_ptr(this->k)
+// CHECK-NEXT: #pragma omp target is_device_ptr(this->k){{$}}
 // CHECK-NEXT: {
 // CHECK-NEXT: }
 // CHECK-NEXT: #pragma omp target is_device_ptr(this->z)
 // CHECK-NEXT: {
 // CHECK-NEXT: }
 // CHECK-NEXT: #pragma omp target is_device_ptr(this->aa)
 // CHECK-NEXT: {
 // CHECK-NEXT: }

test/OpenMP/target_parallel_ast_print.cpp

 }
 
 // CHECK: template <typename T, int C> T tmain(T argc, T *argv) {
 // CHECK-NEXT: T b = argc, c, d, e, f, g;
 // CHECK-NEXT: static T h;
 // CHECK-NEXT: S<T> s;
 // CHECK-NEXT: T arr[C][10], arr1[C];
 // CHECK-NEXT: T i, j, a[20]
-// CHECK-NEXT: #pragma omp target parallel
+// CHECK-NEXT: #pragma omp target parallel{{$}}
 // CHECK-NEXT: h = 2;
 // CHECK-NEXT: #pragma omp target parallel default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(C) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: e,arr[:C][0:10])
 // CHECK-NEXT: foo()
 // CHECK-NEXT: #pragma omp target parallel if(C) num_threads(s) proc_bind(close) reduction(^: e,f,arr[0:C][:argc]) reduction(&&: g)
 // CHECK-NEXT: foo()
 // CHECK-NEXT: #pragma omp target parallel if(target: argc > 0)
 // CHECK-NEXT: foo()
 // CHECK-NEXT: #pragma omp target parallel if(parallel: argc > 0)

test/OpenMP/target_parallel_for_ast_print.cpp

#pragma omp target parallel for private(a) private(this->a) private(T::a)
   S7 &operator=(S7 &s) {
 #pragma omp target parallel for private(a) private(this->a)
     for (int k = 0; k < s.a.a; ++k)
       ++s.a.a;
     return *this;
   }
 };
 
-// CHECK: #pragma omp target parallel for private(this->a) private(this->a) private(T::a)
+// CHECK: #pragma omp target parallel for private(this->a) private(this->a) private(T::a){{$}}
 // CHECK: #pragma omp target parallel for private(this->a) private(this->a)
 // CHECK: #pragma omp target parallel for private(this->a) private(this->a) private(this->S::a)
 
 class S8 : public S7<S> {
   S8() {}
 
 public:
   S8(int v) : S7<S>(v){

test/OpenMP/target_parallel_for_is_device_ptr_ast_print.cpp

 // CHECK-NEXT: STarr &rg = this->g;
 // CHECK-NEXT: int i;
 // CHECK-NEXT: int &j = this->i;
 // CHECK-NEXT: int *k = &this->j;
 // CHECK-NEXT: int *&z = this->k;
 // CHECK-NEXT: int aa[10];
 // CHECK-NEXT: arr &raa = this->aa;
 // CHECK-NEXT: func(
-// CHECK-NEXT: #pragma omp target parallel for is_device_ptr(this->k)
+// CHECK-NEXT: #pragma omp target parallel for is_device_ptr(this->k){{$}}
 // CHECK-NEXT: for (int i = 0; i < 100; i++)
 // CHECK-NEXT: foo();
 // CHECK-NEXT: #pragma omp target parallel for is_device_ptr(this->z)
 // CHECK-NEXT: for (int i = 0; i < 100; i++)
 // CHECK-NEXT: foo();
 // CHECK-NEXT: #pragma omp target parallel for is_device_ptr(this->aa)
 // CHECK-NEXT: for (int i = 0; i < 100; i++)
 // CHECK-NEXT: foo();

test/OpenMP/target_parallel_for_simd_ast_print.cpp

#pragma omp target parallel for simd private(a) private(this->a) private(T::a)
   S7 &operator=(S7 &s) {
 #pragma omp target parallel for simd private(a) private(this->a)
     for (int k = 0; k < s.a.a; ++k)
       ++s.a.a;
     return *this;
   }
 };
 
-// CHECK: #pragma omp target parallel for simd private(this->a) private(this->a) private(T::a)
+// CHECK: #pragma omp target parallel for simd private(this->a) private(this->a) private(T::a){{$}}
 // CHECK: #pragma omp target parallel for simd private(this->a) private(this->a)
 // CHECK: #pragma omp target parallel for simd private(this->a) private(this->a) private(this->S::a)
 
 class S8 : public S7<S> {
   S8() {}
 
 public:
   S8(int v) : S7<S>(v){

test/OpenMP/target_parallel_for_simd_is_device_ptr_ast_print.cpp

 // CHECK-NEXT: STarr &rg = this->g;
 // CHECK-NEXT: int i;
 // CHECK-NEXT: int &j = this->i;
 // CHECK-NEXT: int *k = &this->j;
 // CHECK-NEXT: int *&z = this->k;
 // CHECK-NEXT: int aa[10];
 // CHECK-NEXT: arr &raa = this->aa;
 // CHECK-NEXT: func(
-// CHECK-NEXT: #pragma omp target parallel for simd is_device_ptr(this->k)
+// CHECK-NEXT: #pragma omp target parallel for simd is_device_ptr(this->k){{$}}
 // CHECK-NEXT: for (int i = 0; i < 100; i++)
 // CHECK-NEXT: ;
 // CHECK-NEXT: #pragma omp target parallel for simd is_device_ptr(this->z)
 // CHECK-NEXT: for (int i = 0; i < 100; i++)
 // CHECK-NEXT: ;
 // CHECK-NEXT: #pragma omp target parallel for simd is_device_ptr(this->aa)
 // CHECK-NEXT: for (int i = 0; i < 100; i++)
 // CHECK-NEXT: ;

test/OpenMP/target_parallel_is_device_ptr_ast_print.cpp

 // CHECK-NEXT: STarr &rg = this->g;
 // CHECK-NEXT: int i;
 // CHECK-NEXT: int &j = this->i;
 // CHECK-NEXT: int *k = &this->j;
 // CHECK-NEXT: int *&z = this->k;
 // CHECK-NEXT: int aa[10];
 // CHECK-NEXT: arr &raa = this->aa;
 // CHECK-NEXT: func(
-// CHECK-NEXT: #pragma omp target parallel is_device_ptr(this->k)
+// CHECK-NEXT: #pragma omp target parallel is_device_ptr(this->k){{$}}
 // CHECK-NEXT: {
 // CHECK-NEXT: }
 // CHECK-NEXT: #pragma omp target parallel is_device_ptr(this->z)
 // CHECK-NEXT: {
 // CHECK-NEXT: }
 // CHECK-NEXT: #pragma omp target parallel is_device_ptr(this->aa)
 // CHECK-NEXT: {
 // CHECK-NEXT: }

test/OpenMP/target_simd_ast_print.cpp

#pragma omp target simd private(a) private(this->a) private(T::a)
   S7 &operator=(S7 &s) {
 #pragma omp target simd private(a) private(this->a)
     for (int k = 0; k < s.a.a; ++k)
       ++s.a.a;
     return *this;
   }
 };
 
-// CHECK: #pragma omp target simd private(this->a) private(this->a) private(T::a)
+// CHECK: #pragma omp target simd private(this->a) private(this->a) private(T::a){{$}}
 // CHECK: #pragma omp target simd private(this->a) private(this->a)
 // CHECK: #pragma omp target simd private(this->a) private(this->a) private(this->S::a)
 
 class S8 : public S7<S> {
   S8() {}
 
 public:
   S8(int v) : S7<S>(v){

test/OpenMP/target_teams_ast_print.cpp

#pragma omp target teams reduction(^:e, f) reduction(&& : g)
   foo();
   return 0;
 }
 
 // CHECK: template <typename T, int C> T tmain(T argc, T *argv) {
 // CHECK-NEXT: T b = argc, c, d, e, f, g;
 // CHECK-NEXT: static T a;
 // CHECK-NEXT: S<T> s;
-// CHECK-NEXT: #pragma omp target teams
+// CHECK-NEXT: #pragma omp target teams{{$}}
 // CHECK-NEXT: a = 2;
 // CHECK-NEXT: #pragma omp target teams default(none) private(argc,b) firstprivate(argv) shared(d) reduction(+: c) reduction(max: e) num_teams(C) thread_limit(d * C)
 // CHECK-NEXT: foo()
 // CHECK-NEXT: #pragma omp target teams reduction(^: e,f) reduction(&&: g)
 // CHECK-NEXT: foo()
 // CHECK: template<> int tmain<int, 5>(int argc, int *argv) {
 // CHECK-NEXT: int b = argc, c, d, e, f, g;
 // CHECK-NEXT: static int a;

test/OpenMP/target_teams_distribute_ast_print.cpp

 template <class T, int N>
 T tmain(T argc) {
   T b = argc, c, d, e, f, g;
   static T a;
 // CHECK: static T a;
 #pragma omp target teams distribute
   for (int i=0; i < 2; ++i)
     a = 2;
-// CHECK: #pragma omp target teams distribute
+// CHECK: #pragma omp target teams distribute{{$}}
 // CHECK-NEXT: for (int i = 0; i < 2; ++i)
 // CHECK-NEXT: a = 2;
 #pragma omp target teams distribute private(argc, b), firstprivate(c, d), collapse(2)
   for (int i = 0; i < 10; ++i)
     for (int j = 0; j < 10; ++j)
       foo();
 // CHECK: #pragma omp target teams distribute private(argc,b) firstprivate(c,d) collapse(2)
 // CHECK-NEXT: for (int i = 0; i < 10; ++i)

test/OpenMP/target_teams_distribute_parallel_for_ast_print.cpp

T tmain(T argc) {
   static T a;
 // CHECK: static T a;
   const T clen = 5;
   const T alen = 16;
   int arr[10];
 #pragma omp target teams distribute parallel for
   for (int i=0; i < 2; ++i)
     a = 2;
-// CHECK: #pragma omp target teams distribute parallel for
+// CHECK: #pragma omp target teams distribute parallel for{{$}}
 // CHECK-NEXT: for (int i = 0; i < 2; ++i)
 // CHECK-NEXT: a = 2;
 #pragma omp target teams distribute parallel for private(argc, b), firstprivate(c, d), collapse(2)
   for (int i = 0; i < 10; ++i)
     for (int j = 0; j < 10; ++j)
       foo();
 // CHECK: #pragma omp target teams distribute parallel for private(argc,b) firstprivate(c,d) collapse(2)
 // CHECK-NEXT: for (int i = 0; i < 10; ++i)

test/OpenMP/target_teams_distribute_parallel_for_is_device_ptr_ast_print.cpp

 // CHECK-NEXT: STarr &rg = this->g;
 // CHECK-NEXT: int i;
 // CHECK-NEXT: int &j = this->i;
 // CHECK-NEXT: int *k = &this->j;
 // CHECK-NEXT: int *&z = this->k;
 // CHECK-NEXT: int aa[10];
 // CHECK-NEXT: arr &raa = this->aa;
 // CHECK-NEXT: func(
-// CHECK-NEXT: #pragma omp target teams distribute parallel for is_device_ptr(this->k)
+// CHECK-NEXT: #pragma omp target teams distribute parallel for is_device_ptr(this->k){{$}}
 // CHECK-NEXT: for (int i = 0; i < 100; i++)
 // CHECK-NEXT: ;
 // CHECK-NEXT: #pragma omp target teams distribute parallel for is_device_ptr(this->z)
 // CHECK-NEXT: for (int i = 0; i < 100; i++)
 // CHECK-NEXT: ;
 // CHECK-NEXT: #pragma omp target teams distribute parallel for is_device_ptr(this->aa)
 // CHECK-NEXT: for (int i = 0; i < 100; i++)
 // CHECK-NEXT: ;

test/OpenMP/target_teams_distribute_parallel_for_simd_ast_print.cpp

T tmain(T argc) {
   static T a;
 // CHECK: static T a;
   const T clen = 5;
   const T alen = 16;
   int arr[10];
 #pragma omp target teams distribute parallel for simd
   for (int i=0; i < 2; ++i)
     a = 2;
-// CHECK: #pragma omp target teams distribute parallel for simd
+// CHECK: #pragma omp target teams distribute parallel for simd{{$}}
 // CHECK-NEXT: for (int i = 0; i < 2; ++i)
 // CHECK-NEXT: a = 2;
 #pragma omp target teams distribute parallel for simd private(argc, b), firstprivate(c, d), collapse(2)
   for (int i = 0; i < 10; ++i)
     for (int j = 0; j < 10; ++j)
       foo();
 // CHECK: #pragma omp target teams distribute parallel for simd private(argc,b) firstprivate(c,d) collapse(2)
 // CHECK-NEXT: for (int i = 0; i < 10; ++i)

test/OpenMP/target_teams_distribute_parallel_for_simd_is_device_ptr_ast_print.cpp

 // CHECK-NEXT: STarr &rg = this->g;
 // CHECK-NEXT: int i;
 // CHECK-NEXT: int &j = this->i;
 // CHECK-NEXT: int *k = &this->j;
 // CHECK-NEXT: int *&z = this->k;
 // CHECK-NEXT: int aa[10];
 // CHECK-NEXT: arr &raa = this->aa;
 // CHECK-NEXT: func(
-// CHECK-NEXT: #pragma omp target teams distribute parallel for simd is_device_ptr(this->k)
+// CHECK-NEXT: #pragma omp target teams distribute parallel for simd is_device_ptr(this->k){{$}}
 // CHECK-NEXT: for (int i = 0; i < 100; i++)
 // CHECK-NEXT: ;
 // CHECK-NEXT: #pragma omp target teams distribute parallel for simd is_device_ptr(this->z)
 // CHECK-NEXT: for (int i = 0; i < 100; i++)
 // CHECK-NEXT: ;
 // CHECK-NEXT: #pragma omp target teams distribute parallel for simd is_device_ptr(this->aa)
 // CHECK-NEXT: for (int i = 0; i < 100; i++)
 // CHECK-NEXT: ;

test/OpenMP/target_teams_distribute_simd_ast_print.cpp

T tmain(T argc) {
   static T a;
 // CHECK: static T a;
   const T clen = 5;
   const T alen = 16;
   int arr[10];
 #pragma omp target teams distribute simd
   for (int i=0; i < 2; ++i)
     a = 2;
-// CHECK: #pragma omp target teams distribute simd
+// CHECK: #pragma omp target teams distribute simd{{$}}
 // CHECK-NEXT: for (int i = 0; i < 2; ++i)
 // CHECK-NEXT: a = 2;
 #pragma omp target teams distribute simd private(argc, b), firstprivate(c, d), collapse(2)
   for (int i = 0; i < 10; ++i)
     for (int j = 0; j < 10; ++j)
       foo();
 // CHECK: #pragma omp target teams distribute simd private(argc,b) firstprivate(c,d) collapse(2)
 // CHECK-NEXT: for (int i = 0; i < 10; ++i)

test/OpenMP/target_teams_distribute_simd_is_device_ptr_ast_print.cpp

 // CHECK-NEXT: STarr &rg = this->g;
 // CHECK-NEXT: int i;
 // CHECK-NEXT: int &j = this->i;
 // CHECK-NEXT: int *k = &this->j;
 // CHECK-NEXT: int *&z = this->k;
 // CHECK-NEXT: int aa[10];
 // CHECK-NEXT: arr &raa = this->aa;
 // CHECK-NEXT: func(
-// CHECK-NEXT: #pragma omp target teams distribute simd is_device_ptr(this->k)
+// CHECK-NEXT: #pragma omp target teams distribute simd is_device_ptr(this->k){{$}}
 // CHECK-NEXT: for (int i = 0; i < 100; i++)
 // CHECK-NEXT: ;
 // CHECK-NEXT: #pragma omp target teams distribute simd is_device_ptr(this->z)
 // CHECK-NEXT: for (int i = 0; i < 100; i++)
 // CHECK-NEXT: ;
 // CHECK-NEXT: #pragma omp target teams distribute simd is_device_ptr(this->aa)
 // CHECK-NEXT: for (int i = 0; i < 100; i++)
 // CHECK-NEXT: ;

test/OpenMP/target_teams_is_device_ptr_ast_print.cpp

 // CHECK-NEXT: STarr &rg = this->g;
 // CHECK-NEXT: int i;
 // CHECK-NEXT: int &j = this->i;
 // CHECK-NEXT: int *k = &this->j;
 // CHECK-NEXT: int *&z = this->k;
 // CHECK-NEXT: int aa[10];
 // CHECK-NEXT: arr &raa = this->aa;
 // CHECK-NEXT: func(
-// CHECK-NEXT: #pragma omp target teams is_device_ptr(this->k)
+// CHECK-NEXT: #pragma omp target teams is_device_ptr(this->k){{$}}
 // CHECK-NEXT: {
 // CHECK-NEXT: }
 // CHECK-NEXT: #pragma omp target teams is_device_ptr(this->z)
 // CHECK-NEXT: {
 // CHECK-NEXT: }
 // CHECK-NEXT: #pragma omp target teams is_device_ptr(this->aa)
 // CHECK-NEXT: {
 // CHECK-NEXT: }

test/OpenMP/target_update_ast_print.cpp

 #pragma omp target update to(a) if(l>5) device(l) nowait depend(inout:l)
 
 #pragma omp target update from(b) if(l<5) device(l-1) nowait depend(inout:l)
   return a + targ + (T)b;
 }
 // CHECK:      static T a;
 // CHECK-NEXT: U b;
 // CHECK-NEXT: int l;
-// CHECK-NEXT: #pragma omp target update to(a) if(l > 5) device(l) nowait depend(inout : l)
+// CHECK-NEXT: #pragma omp target update to(a) if(l > 5) device(l) nowait depend(inout : l){{$}}
 // CHECK-NEXT: #pragma omp target update from(b) if(l < 5) device(l - 1) nowait depend(inout : l)
 // CHECK:      static int a;
 // CHECK-NEXT: float b;
 // CHECK-NEXT: int l;
 // CHECK-NEXT: #pragma omp target update to(a) if(l > 5) device(l) nowait depend(inout : l)
 // CHECK-NEXT: #pragma omp target update from(b) if(l < 5) device(l - 1) nowait depend(inout : l)
 // CHECK:      static char a;
 // CHECK-NEXT: float b;

test/OpenMP/task_ast_print.cpp

 #pragma omp task private(a) private(this->a)
     for (int k = 0; k < s.a.a; ++k)
       ++s.a.a;
     return *this;
   }
 };
 
 // CHECK: #pragma omp taskgroup task_reduction(+: this->b)
-// CHECK: #pragma omp task private(this->a) private(this->a) private(T::a) in_reduction(+: this->b)
+// CHECK: #pragma omp task private(this->a) private(this->a) private(T::a) in_reduction(+: this->b){{$}}
 // CHECK: #pragma omp task private(this->a) private(this->a)
 // CHECK: #pragma omp task private(this->a) private(this->a) private(this->S1::a)
 
 class S8 : public S7<S1> {
   S8() {}
 
 public:
   S8(int v) : S7<S1>(v){

test/OpenMP/taskgroup_ast_print.cpp

 // CHECK: #pragma omp taskgroup task_reduction(*: this->a) task_reduction(&&: this->b[this->a.a:])
 
 int main (int argc, char **argv) {
   int b = argc, c, d, e, f, g;
   static int a;
 // CHECK: static int a;
 #pragma omp taskgroup
   a=2;
-// CHECK-NEXT: #pragma omp taskgroup
+// CHECK-NEXT: #pragma omp taskgroup{{$}}
 // CHECK-NEXT: a = 2;
 // CHECK-NEXT: ++a;
   ++a;
 #pragma omp taskgroup task_reduction(min: a)
   foo();
 // CHECK-NEXT: #pragma omp taskgroup task_reduction(min: a)
 // CHECK-NEXT: foo();
 // CHECK-NEXT: return 0;
   return 0;
 }
 
 #endif

test/OpenMP/taskloop_ast_print.cpp

 template <class T, int N>
 T tmain(T argc) {
   T b = argc, c, d, e, f, g;
   static T a;
 // CHECK: static T a;
 #pragma omp taskgroup task_reduction(+: d)
 #pragma omp taskloop if(taskloop: argc > N) default(shared) untied priority(N) grainsize(N) reduction(+:g) in_reduction(+: d)
   // CHECK-NEXT: #pragma omp taskgroup task_reduction(+: d)
-  // CHECK-NEXT: #pragma omp taskloop if(taskloop: argc > N) default(shared) untied priority(N) grainsize(N) reduction(+: g) in_reduction(+: d)
+  // CHECK-NEXT: #pragma omp taskloop if(taskloop: argc > N) default(shared) untied priority(N) grainsize(N) reduction(+: g) in_reduction(+: d){{$}}
   for (int i = 0; i < 2; ++i)
     a = 2;
 // CHECK-NEXT: for (int i = 0; i < 2; ++i)
 // CHECK-NEXT: a = 2;
 #pragma omp parallel
 #pragma omp taskloop private(argc, b), firstprivate(c, d), lastprivate(d, f) collapse(N) shared(g) if (c) final(d) mergeable priority(f) nogroup num_tasks(N)
   for (int i = 0; i < 2; ++i)
     for (int j = 0; j < 2; ++j)

test/OpenMP/taskloop_simd_ast_print.cpp

 T tmain(T argc) {
   T b = argc, c, d, e, f, g;
   T *ptr;
   static T a;
 // CHECK: static T a;
 #pragma omp taskgroup task_reduction(+: d)
 #pragma omp taskloop simd if(taskloop: argc > N) default(shared) untied priority(N) safelen(N) linear(c) aligned(ptr) grainsize(N) reduction(+:g) in_reduction(+: d)
   // CHECK-NEXT: #pragma omp taskgroup task_reduction(+: d)
-  // CHECK-NEXT: #pragma omp taskloop simd if(taskloop: argc > N) default(shared) untied priority(N) safelen(N) linear(c) aligned(ptr) grainsize(N) reduction(+: g) in_reduction(+: d)
+  // CHECK-NEXT: #pragma omp taskloop simd if(taskloop: argc > N) default(shared) untied priority(N) safelen(N) linear(c) aligned(ptr) grainsize(N) reduction(+: g) in_reduction(+: d){{$}}
   for (int i = 0; i < 2; ++i)
     a = 2;
 // CHECK-NEXT: for (int i = 0; i < 2; ++i)
 // CHECK-NEXT: a = 2;
 #pragma omp parallel
 #pragma omp taskloop simd private(argc, b), firstprivate(c, d), lastprivate(d, f) collapse(N) shared(g) if (c) final(d) mergeable priority(f) simdlen(N) nogroup num_tasks(N)
   for (int i = 0; i < 2; ++i)
     for (int j = 0; j < 2; ++j)

test/OpenMP/taskwait_ast_print.cpp

 
 template <class T>
 T tmain(T argc) {
   static T a;
 #pragma omp taskwait
   return a + argc;
 }
 // CHECK:      static T a;
-// CHECK-NEXT: #pragma omp taskwait
+// CHECK-NEXT: #pragma omp taskwait{{$}}
 // CHECK:      static int a;
 // CHECK-NEXT: #pragma omp taskwait
 // CHECK:      static char a;
 // CHECK-NEXT: #pragma omp taskwait
 
 int main(int argc, char **argv) {
   static int a;
 // CHECK: static int a;
 #pragma omp taskwait
   // CHECK-NEXT: #pragma omp taskwait
   return tmain(argc) + tmain(argv[0][0]) + a;
 }
 
 #endif

test/OpenMP/taskyield_ast_print.cpp

 
 template <class T>
 T tmain(T argc) {
   static T a;
 #pragma omp taskyield
   return a + argc;
 }
 // CHECK:      static T a;
-// CHECK-NEXT: #pragma omp taskyield
+// CHECK-NEXT: #pragma omp taskyield{{$}}
 // CHECK:      static int a;
 // CHECK-NEXT: #pragma omp taskyield
 // CHECK:      static char a;
 // CHECK-NEXT: #pragma omp taskyield
 
 int main(int argc, char **argv) {
   static int a;
 // CHECK: static int a;
 #pragma omp taskyield
   // CHECK-NEXT: #pragma omp taskyield
   return tmain(argc) + tmain(argv[0][0]) + a;
 }
 
 #endif

test/OpenMP/teams_ast_print.cpp

#pragma omp teams reduction(^:e, f) reduction(&& : g)
   return 0;
 }
 
 // CHECK: template <typename T, int C> T tmain(T argc, T *argv) {
 // CHECK-NEXT: T b = argc, c, d, e, f, g;
 // CHECK-NEXT: static T a;
 // CHECK-NEXT: S<T> s;
 // CHECK-NEXT: #pragma omp target
-// CHECK-NEXT: #pragma omp teams
+// CHECK-NEXT: #pragma omp teams{{$}}
 // CHECK-NEXT: a = 2;
 // CHECK-NEXT: #pragma omp target
 // CHECK-NEXT: #pragma omp teams default(none) private(argc,b) firstprivate(argv) shared(d) reduction(+: c) reduction(max: e) num_teams(C) thread_limit(d * C)
 // CHECK-NEXT: foo()
 // CHECK-NEXT: #pragma omp target
 // CHECK-NEXT: #pragma omp teams reduction(^: e,f) reduction(&&: g)
 // CHECK-NEXT: foo()
 // CHECK: template<> int tmain<int, 5>(int argc, int *argv) {

test/OpenMP/teams_distribute_ast_print.cpp

T tmain(T argc) {
   T b = argc, c, d, e, f, g;
   static T a;
 // CHECK: static T a;
 #pragma omp target
 #pragma omp teams distribute
   for (int i=0; i < 2; ++i)
     a = 2;
 // CHECK: #pragma omp target
-// CHECK-NEXT: #pragma omp teams distribute
+// CHECK-NEXT: #pragma omp teams distribute{{$}}
 // CHECK-NEXT: for (int i = 0; i < 2; ++i)
 // CHECK-NEXT: a = 2;
 #pragma omp target
 #pragma omp teams distribute private(argc, b), firstprivate(c, d), collapse(2)
   for (int i = 0; i < 10; ++i)
     for (int j = 0; j < 10; ++j)
       foo();
 // CHECK: #pragma omp target

test/OpenMP/teams_distribute_parallel_for_ast_print.cpp

// CHECK: static T a;
   const T clen = 5;
   const T alen = 16;
   int arr[10];
 #pragma omp target
 #pragma omp teams distribute parallel for
   for (int i=0; i < 2; ++i)
     a = 2;
 // CHECK: #pragma omp target
-// CHECK-NEXT: #pragma omp teams distribute parallel for
+// CHECK-NEXT: #pragma omp teams distribute parallel for{{$}}
 // CHECK-NEXT: for (int i = 0; i < 2; ++i)
 // CHECK-NEXT: a = 2;
 #pragma omp target
 #pragma omp teams distribute parallel for private(argc, b), firstprivate(c, d), collapse(2)
   for (int i = 0; i < 10; ++i)
     for (int j = 0; j < 10; ++j)
       foo();
 // CHECK: #pragma omp target

test/OpenMP/teams_distribute_parallel_for_simd_ast_print.cpp

// CHECK: static T a;
   const T clen = 5;
   const T alen = 16;
   int arr[10];
 #pragma omp target
 #pragma omp teams distribute parallel for simd
   for (int i=0; i < 2; ++i)
     a = 2;
 // CHECK: #pragma omp target
-// CHECK-NEXT: #pragma omp teams distribute parallel for simd
+// CHECK-NEXT: #pragma omp teams distribute parallel for simd{{$}}
 // CHECK-NEXT: for (int i = 0; i < 2; ++i)
 // CHECK-NEXT: a = 2;
 #pragma omp target
 #pragma omp teams distribute parallel for simd private(argc, b), firstprivate(c, d), collapse(2)
   for (int i = 0; i < 10; ++i)
     for (int j = 0; j < 10; ++j)
       foo();
 // CHECK: #pragma omp target

test/OpenMP/teams_distribute_simd_ast_print.cpp

// CHECK: static T a;
   const T clen = 5;
   const T alen = 16;
   int arr[10];
 #pragma omp target
 #pragma omp teams distribute simd
   for (int i=0; i < 2; ++i)
     a = 2;
 // CHECK: #pragma omp target
-// CHECK-NEXT: #pragma omp teams distribute simd
+// CHECK-NEXT: #pragma omp teams distribute simd{{$}}
 // CHECK-NEXT: for (int i = 0; i < 2; ++i)
 // CHECK-NEXT: a = 2;
 #pragma omp target
 #pragma omp teams distribute simd private(argc, b), firstprivate(c, d), collapse(2)
   for (int i = 0; i < 10; ++i)
     for (int j = 0; j < 10; ++j)
       foo();
 // CHECK: #pragma omp target

test/OpenMP/threadprivate_ast_print.cpp

  int a;
 };
 
 struct St1{
  int a;
  static int b;
 // CHECK: static int b;
 #pragma omp threadprivate(b)
-// CHECK-NEXT: #pragma omp threadprivate(St1::b)
+// CHECK-NEXT: #pragma omp threadprivate(St1::b){{$}}
 } d;
 
 int a, b;
 // CHECK: int a;
 // CHECK: int b;
 #pragma omp threadprivate(a)
 #pragma omp threadprivate(a)
 // CHECK-NEXT: #pragma omp threadprivate(a)

test/PCH/pragma-loop.cpp

 // RUN: %clang_cc1 -emit-pch -o %t.a %s
 // RUN: %clang_cc1 -include-pch %t.a %s -ast-print -o - | FileCheck %s
 
 // FIXME: A bug in ParsedAttributes causes the order of the attributes to be
 // reversed. The checks are consequently in the reverse order below.
 
-// CHECK: #pragma clang loop unroll_count(16)
+// CHECK: #pragma clang loop unroll_count(16){{$}}
 // CHECK: #pragma clang loop interleave_count(8)
 // CHECK: #pragma clang loop vectorize_width(4)
 // CHECK: #pragma clang loop distribute(enable)
 // CHECK: #pragma clang loop unroll(disable)
 // CHECK: #pragma clang loop interleave(disable)
 // CHECK: #pragma clang loop vectorize(enable)
 // CHECK: #pragma clang loop distribute(disable)
 // CHECK: #pragma clang loop unroll(full)
 // CHECK: #pragma clang loop interleave(enable)
 // CHECK: #pragma clang loop vectorize(disable)
-// CHECK: #pragma unroll
-// CHECK: #pragma unroll (32)
-// CHECK: #pragma nounroll
+// FIXME: "#pragma unroll (enable)" is invalid and is not the input source.
+// CHECK: #pragma unroll (enable){{$}}
+// CHECK: #pragma unroll (32){{$}}
+// CHECK: #pragma nounroll{{$}}
 // CHECK: #pragma clang loop interleave_count(I)
 // CHECK: #pragma clang loop vectorize_width(V)
 
 #ifndef HEADER
 #define HEADER
 
 class pragma_test {
 public:

utils/TableGen/ClangAttrEmitter.cpp

for (unsigned I = 0; I < Spellings.size(); ++ I) {
 
     Spelling += Name;
 
     OS <<
       "  case " << I << " : {\n"
       "    OS << \"" << Prefix << Spelling;
 
     if (Variety == "Pragma") {
-      OS << " \";\n";
+      OS << "\";\n";
       OS << "    printPrettyPragma(OS, Policy);\n";
       OS << "    OS << \"\\n\";";
       OS << "    break;\n";
       OS << "  }\n";
       continue;
     }
 
     // Fake arguments aren't part of the parsed form and should not be