Meta directive runtime support

[abidmalikwaterloo]

Summary

The patch extends the current implementation
for runtime support. The current patch build AST
of the when clauses in sorted order using the
context selector score

[jdoerfert]

This contains a lot of unrelated changes, leftover comments, etc. As you clean up the code, please also include tests. Clang format the patch, go over the new code and make sure you follow the coding style. Remove unneeded parts (e.g., a map into which you simply push objects then take them out to push them into a vector).

Also, have you seen D120573?

[abidmalikwaterloo]

I quickly went through the D120573. There are many overlapping.

[abidmalikwaterloo]

Is it okay if I can put comments on the patch?

[jdoerfert]

In D122255#3400636, @abidmalikwaterloo wrote:

Is it okay if I can put comments on the patch?

Not sure what you mean but feel free.

[abidmalikwaterloo]

would it make sense to submit separate patches for when (OMPC_when) and otherwise (OMPC_otherwise) clauses? The D120573 also has OMPC_when support.

[abidmalikwaterloo]

There should be an update to D122255. It should not create the new one.D123598
--->
I did the following :
arc patch D122255
"did something/cleaning"
git commit -a
arc diff
---->

[abidmalikwaterloo]

I update it but it created a new patch D123598.
I marked it Abandon. Not sure how to delete it.
I am submitting it again after cleaning the codes
and adding some basic tests.

[abidmalikwaterloo]

Added tests

[abidmalikwaterloo]

The last update removed all previous updates. Can you point me to the correct way to do it?
I did the following :
arc patch D122255
"did something/cleaning"
git commit -a --amend
arc diff

[abidmalikwaterloo]

Cleaned the code and added tests.

[abidmalikwaterloo]

Should I update the patch? I am waiting for quick feedback on the concept of handling conditions.

[ABataev]

clang/include/clang/AST/OpenMPClause.h

8866

condition?

8900–8901

make it private

8907

const

8912

const

clang/include/clang/AST/StmtOpenMP.h

5479

Remove this change

clang/include/clang/Basic/DiagnosticSemaKinds.td

10852 ↗

(On Diff #423305)

We do not use explamations in messages, better to have something only single default ...

clang/include/clang/Sema/Sema.h

10686

Comment for this new function

11141

formatting

clang/lib/AST/OpenMPClause.cpp

1614–1617

Is this correct? Just default( is expected to be printed?

clang/lib/AST/StmtPrinter.cpp

658

Do not insert empty line here

659–660

formatting

663

use isa

665

Camel naming style expceted

666

formatting, use nullptr instead of NULL (or just C)

667

Formatting

clang/lib/Parse/ParseOpenMP.cpp

2433

What is this?

2474

Restore original code here

2498–2507

Remove this extra stuff

2546

What A stands after, what does it mean?

[abidmalikwaterloo]

clang/include/clang/AST/OpenMPClause.h

8900–8901

Any reason behind this? I went through other classes, this function is public in some and private in some.

[ABataev]

clang/include/clang/AST/OpenMPClause.h

8900–8901

The AST is immutable, such functions are/must be used in very rare places.

[abidmalikwaterloo]

Updated and clean the code based on the comments from
the reviewer!

[abidmalikwaterloo]

Ping!

clang/lib/AST/OpenMPClause.cpp

1614–1617

This function is called from StmtPrinter::PrintOMPExecutableDirective in StmtPrinter.CPP. The enclosed Directive and the second matching brace will be printed. See line # 670 in StmtPrinter.CPP

clang/lib/Parse/ParseOpenMP.cpp

2433

comment removed

[jdoerfert]

clang/include/clang/Basic/DiagnosticSemaKinds.td

10852 ↗

(On Diff #423305)

"allowed in" what? Also, there is no test for this, or is there?

clang/lib/AST/OpenMPClause.cpp

1614–1617

The problem is this doesn't make sense. For one, StmtPrinter calls this function conditionally, so you might end up with a lonely closing parenthesis. Also, why would we split the parenthesis into two places?

1679

I'm assuming we already have a printer for trait selectors, no? Doesn't OMPTraitInfo::print do this already and actually handle scores?

clang/lib/AST/StmtPrinter.cpp

677

clang/lib/Parse/ParseOpenMP.cpp

2474

There are plenty of formatting changes in this file and elsewhere. Please retore the original code or properly clang-format the patch.

2547

typo

2568

We don't use comments like these.

2590

This seems to be copied from somewhere. It is unclear why a metadirective needs to have an associated openmp region.

clang/lib/Sema/SemaOpenMP.cpp

4705

Still unrelated newlines.

7400

Code style, ArchMatch.

7449

Why does this perform partial trait matching? We should have code for this. Also, the logic for device_arch and vendor (which is most what there is), is not what we want. Reuse the existing matching logic instead.

clang/lib/Sema/SemaStmt.cpp

4796

Unrelated. Please go over the patch and avoid these in the future. We have so many comments that point out these things that now the comments make it hard to read/review.

clang/test/OpenMP/metadirective_ast_print_new_1.cpp

20 ↗

(On Diff #442661)

I doubt clang format handles the metadirective well but maybe format the code first without the pragma. This is hard to read. Also the other tests.

You only have ast print tests, what about the rest? Messages (errors/warnings) and codegen?

llvm/lib/Frontend/OpenMP/OMPContext.cpp

377

This does not sort scores properly and for some reason uses a Map as a intermediate storage.
Instead, please combine this with the function below, which already has a proper score comparator.

[abidmalikwaterloo]

clang/include/clang/Basic/DiagnosticSemaKinds.td

10852 ↗

(On Diff #423305)

It should be "Only one default clause is allowed.

clang/lib/AST/OpenMPClause.cpp

1679

Looked into the function. OMPTraitInfo::print can be used. The function needs to be extended as well to take the other traits as well.

clang/lib/Sema/SemaOpenMP.cpp

7449

Ok. What do you mean by existing matching logic?

clang/lib/Sema/SemaStmt.cpp

4796

An accidental tap. Removed

[abidmalikwaterloo]

clang/include/clang/AST/RecursiveASTVisitor.h

3144 ↗

(On Diff #442661)

If it is not the user's condition or score then what will happen?

clang/lib/Sema/SemaOpenMP.cpp

7449

@jdoerfert I agree that the implementation is incomplete in terms of trait matching. It can be completed. However, I am not clear about your comments about the existing matching logic. I checked OMPContext.CPP and other files. There are functions that can be used to match the traits. But, I could not find any existing logic that can be used here.

[jdoerfert]

clang/lib/AST/OpenMPClause.cpp

1679

The function needs to be extended as well to take the other traits as well.

What traits are not handled there?

clang/lib/Sema/SemaOpenMP.cpp

7449

I mean getBestVariantMatchForContext and similar functions in llvm/lib/Frontend/OpenMP/OMPContext.cpp.

[abidmalikwaterloo]

I will work on the patch in parts. I am planning to submit taking care of comments except for comments for SemaOpenMP and code generation.

clang/lib/AST/OpenMPClause.cpp

1679

No. It handles everything in terms of printing. I have updated the code. Will upload it as well.

clang/lib/Parse/ParseOpenMP.cpp

2590

correcrted.

clang/lib/Sema/SemaOpenMP.cpp

7449

OK.

[abidmalikwaterloo]

Updated the PrintStmt.cpp according to the comments

[ABataev]

clang/lib/AST/OpenMPClause.cpp

19

Remove empty comment

1619–1620

if (Stmt *S = Node->getDirective())

2454–2462

Remove those empty new lines

[abidmalikwaterloo]

Clean the formatting comments. The patch is out of attention
for a while. Still need to work on the context selector part
as a next step.

[abidmalikwaterloo]

Rebase the patch to origin/main with all updates. Made changes
to make it buildable using the new changes.
(WIP).

clang/include/clang/AST/OpenMPClause.h

 //===- OpenMPClause.h - Classes for OpenMP clauses --------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
public:
 
   const_child_range children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
 
   child_range used_children() {
     return child_range(child_iterator(), child_iterator());
   }
+  
   const_child_range used_children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
 
   static bool classof(const OMPClause *T) {
     return T->getClauseKind() == llvm::omp::OMPC_bind;
   }
 };
 
-/// This represents 'when' clause in the '#pragma omp ...' directive
-///
-/// \code
-/// #pragma omp metadirective when(user={condition(N<10)} : parallel for) \
-///            when(user={condition(N> 10)}: parallel)\  
-/// \endcode
-/// In this example directive '#pragma omp metadirective' has two 'when'
-/// clauses with user defined conditions.
-
-
-
 
 /// This class implements a simple visitor for OMPClause
 /// subclasses.
 template<class ImplClass, template <typename> class Ptr, typename RetTy>
 class OMPClauseVisitorBase {
 public:
 #define PTR(CLASS) Ptr<CLASS>
 #define DISPATCH(CLASS) \

 template <typename T> using const_ptr = std::add_pointer_t<std::add_const_t<T>>;
 
 template <class ImplClass, typename RetTy = void>
 class OMPClauseVisitor
     : public OMPClauseVisitorBase<ImplClass, std::add_pointer_t, RetTy> {};
 template<class ImplClass, typename RetTy = void>
 class ConstOMPClauseVisitor :
       public OMPClauseVisitorBase <ImplClass, const_ptr, RetTy> {};
            
-     
-/*
-class OMPClausePrinter final : public OMPClauseVisitor<OMPClausePrinter> {
-  raw_ostream &OS;
-  const PrintingPolicy &Policy;
-
-  /// Process clauses with list of variables.
-  template <typename T> void VisitOMPClauseList(T *Node, char StartSym);
-  /// Process motion clauses.
-  template <typename T> void VisitOMPMotionClause(T *Node);
-
-public:
-  OMPClausePrinter(raw_ostream &OS, const PrintingPolicy &Policy)
-      : OS(OS), Policy(Policy) {}
-      
- // void VisitOMPWhenClause(OMPWhenClause *Node);
-  
-#define GEN_CLANG_CLAUSE_CLASS
-#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *S);
-#include "llvm/Frontend/OpenMP/OMP.inc"
-};
-
-*/
-
 struct OMPTraitProperty {
   llvm::omp::TraitProperty Kind = llvm::omp::TraitProperty::invalid;
 
   /// The raw string as we parsed it. This is needed for the `isa` trait set
   /// (which accepts anything) and (later) extensions.
   StringRef RawString;
 };
 struct OMPTraitSelector {
if (!HasAssociatedStmt)
       return Stmt::child_range(Stmt::child_iterator(), Stmt::child_iterator());
     return Stmt::child_range(&getTrailingObjects<Stmt *>()[NumChildren],
                              &getTrailingObjects<Stmt *>()[NumChildren + 1]);
   }
 };
 
 /// This captures 'when' clause in the '#pragma omp metadirective'
 /// \code
 /// #pragma omp metadirective when(user={consition(N<100)}:parallel for)
 /// \endcode
 /// In the above example, the metadirective clause has a condition which when
 /// satisfied will use the parallel for directive with the code enclosed by the
 /// directive.
 class OMPWhenClause final : public OMPClause {
   friend class OMPClauseReader;
 
   OMPTraitInfo *TI;
OMPWhenClause(OMPTraitInfo &T, OpenMPDirectiveKind dKind, Stmt *D,
                 SourceLocation EndLoc)
       : OMPClause(llvm::omp::OMPC_when, StartLoc, EndLoc), TI(&T), DKind(dKind),
         Directive(D), LParenLoc(LParenLoc) {}
 
   /// Build an empty clause.
   OMPWhenClause()
       : OMPClause(llvm::omp::OMPC_when, SourceLocation(), SourceLocation()) {}
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
   /// Returns the location of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
   /// Returns the directive variant kind
   OpenMPDirectiveKind getDKind() { return DKind; }
 
   Stmt *getDirective() const { return Directive; }
 
   /// Returns the OMPTraitInfo
   OMPTraitInfo &getTI() { return *TI; }
 
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
 
   const_child_range children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
   }

clang/include/clang/AST/StmtOpenMP.h

 //===- StmtOpenMP.h - Classes for OpenMP directives  ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file

 
 public:
   static OMPMetaDirective *Create(const ASTContext &C, SourceLocation StartLoc,
                                   SourceLocation EndLoc,
                                   ArrayRef<OMPClause *> Clauses,
                                   Stmt *AssociatedStmt, Stmt *IfStmt);
   static OMPMetaDirective *CreateEmpty(const ASTContext &C, unsigned NumClauses,
                                        EmptyShell);
-                                       
   Stmt *getIfStmt() const { return IfStmt; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPMetaDirectiveClass;
   }
 };
 
 /// This represents '#pragma omp loop' directive.
 ///

clang/include/clang/Parse/Parser.h

 //===--- Parser.h - C Language Parser ---------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
private:
   /// \param AllowScopeSpecifier true, if the variables can have fully
   /// qualified names.
   ///
   bool ParseOpenMPSimpleVarList(
       OpenMPDirectiveKind Kind,
       const llvm::function_ref<void(CXXScopeSpec &, DeclarationNameInfo)> &
           Callback,
       bool AllowScopeSpecifier);
+      
   /// Parses declarative or executable directive.
   ///
   /// \param StmtCtx The context in which we're parsing the directive.
+  ///
   StmtResult
   ParseOpenMPDeclarativeOrExecutableDirective(ParsedStmtContext StmtCtx);
   /// Parse clause for metadirective
+  ///
   /// \param Dkind Kind of current directive
   /// \param CKind Kind of current clause
   /// 
   OMPClause *ParseOpenMPMetaDirectiveClause(OpenMPDirectiveKind DKind,
                                             OpenMPClauseKind CKind);
   /// Parses clause of kind \a CKind for directive of a kind \a Kind.
   ///
   /// \param DKind Kind of current directive.

clang/include/clang/Sema/Sema.h

 //===--- Sema.h - Semantic Analysis & AST Building --------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
public:
   /// \param Clauses List of clauses for the current OpenMP region.
   ///
   /// \returns Statement for finished OpenMP region.
   StmtResult ActOnOpenMPRegionEnd(StmtResult S, ArrayRef<OMPClause *> Clauses);
   StmtResult ActOnOpenMPExecutableDirective(
       OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName,
       OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses,
       Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc);
-  StmtResult ActOnOpenMPExecutableMetaDirective( // This might be needed later
+  
+  /// Called on '\#pragma omp metadirective' after parsing
+  ///
+  ///
+  /// \returns Statement for metadirective    
+  StmtResult ActOnOpenMPExecutableMetaDirective( 
       OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName, 
       OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses,
       Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc);
+      
   /// Called on well-formed '\#pragma omp parallel' after parsing
   /// of the  associated statement.
   StmtResult ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
                                           Stmt *AStmt,
                                           SourceLocation StartLoc,
                                           SourceLocation EndLoc);
   using VarsWithInheritedDSAType =
       llvm::SmallDenseMap<const ValueDecl *, const Expr *, 4>;
public:
 
   OMPClause *ActOnOpenMPSimpleClause(OpenMPClauseKind Kind,
                                      unsigned Argument,
                                      SourceLocation ArgumentLoc,
                                      SourceLocation StartLoc,
                                      SourceLocation LParenLoc,
                                      SourceLocation EndLoc);
   /// Called on well-formed 'when' clause.
-  /// Abid
   OMPClause *ActOnOpenMPWhenClause(OMPTraitInfo &TI, OpenMPDirectiveKind DKind,
               StmtResult Directive,  
               SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation EndLoc);
   /// Called on well-formed 'default' clause.
   OMPClause *ActOnOpenMPDefaultClause(llvm::omp::DefaultKind Kind,
                                       SourceLocation KindLoc,
                                       SourceLocation StartLoc,

clang/lib/AST/OpenMPClause.cpp

 //===- OpenMPClause.cpp - Classes for OpenMP clauses ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the subclesses of Stmt class declared in OpenMPClause.h
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/OpenMPClause.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclOpenMP.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/OpenMPKinds.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <algorithm>
 #include <cassert>
 
 using namespace clang;

 
 OMPBindClause *OMPBindClause::CreateEmpty(const ASTContext &C) {
   return new (C) OMPBindClause();
 }
 //===----------------------------------------------------------------------===//
 //  OpenMP clauses printing methods
 //===----------------------------------------------------------------------===//
 
-
 void OMPClausePrinter::VisitOMPWhenClause(OMPWhenClause *Node) {
 
   if (Node->getTI().Sets.size() == 0) {
     OS << "default(";
     return;
   }
   OS << "when(";
   int count = 0;
   for (const OMPTraitSet &Set : Node->getTI().Sets) {
     if (count == 0)
       count++;
     else
       OS << ", ";
     for (const OMPTraitSelector &Selector : Set.Selectors) {
       switch (Selector.Kind) {
       case TraitSelector::device_kind: {
         OS << "device={kind(";
for (const OMPTraitSelector &Selector : Set.Selectors) {
         break;
       }
       case TraitSelector::user_condition: {
         OS << "user={condition(";
         Selector.ScoreOrCondition->printPretty(OS, nullptr, Policy, 0);
         OS << ")}";
         break;
       }
-      
       default:
         break;
       }
     }
   }
   OS << ": ";
 }
 
 void OMPClausePrinter::VisitOMPIfClause(OMPIfClause *Node) {
   OS << "if(";
   if (Node->getNameModifier() != OMPD_unknown)
     OS << getOpenMPDirectiveName(Node->getNameModifier()) << ": ";
   Node->getCondition()->printPretty(OS, nullptr, Policy, 0);
   OS << ")";
 }
for (const OMPTraitSet &Set : Sets) {
     }
   }
 }
 
 void OMPTraitInfo::print(llvm::raw_ostream &OS,
                          const PrintingPolicy &Policy) const {
   bool FirstSet = true;
   for (const OMPTraitSet &Set : Sets) {
     if (!FirstSet)
       OS << ", ";
     FirstSet = false;
     OS << getOpenMPContextTraitSetName(Set.Kind) << "={";
 
     bool FirstSelector = true;
     for (const OMPTraitSelector &Selector : Set.Selectors) {
       if (!FirstSelector)
         OS << ", ";
       FirstSelector = false;
       OS << getOpenMPContextTraitSelectorName(Selector.Kind);
 
       bool AllowsTraitScore = false;
       bool RequiresProperty = false;
       isValidTraitSelectorForTraitSet(
           Selector.Kind, Set.Kind, AllowsTraitScore, RequiresProperty);
 

clang/lib/AST/StmtPrinter.cpp

 //===- StmtPrinter.cpp - Printing implementation for Stmt ASTs ------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 //===----------------------------------------------------------------------===//
 
 void StmtPrinter::VisitOMPCanonicalLoop(OMPCanonicalLoop *Node) {
   PrintStmt(Node->getLoopStmt());
 }
 
 void StmtPrinter::PrintOMPExecutableDirective(OMPExecutableDirective *S,
                                               bool ForceNoStmt) {
-   
-        
   OMPClausePrinter Printer(OS, Policy);
   ArrayRef<OMPClause *> Clauses = S->clauses();
-  for (auto *Clause : Clauses){
-    
+  for (auto *Clause : Clauses){ 
     if (Clause && !Clause->isImplicit()) {
       OS << ' ';
-      Printer.Visit(Clause);
-      
+      Printer.Visit(Clause);    
       if (dyn_cast<OMPMetaDirective>(S)){
-     
         OMPWhenClause *c = dyn_cast<OMPWhenClause>(Clause);
         if (c!=NULL){
           if (c->getDKind() != llvm::omp::OMPD_unknown){
             Printer.VisitOMPWhenClause(c);
             OS << llvm::omp::getOpenMPDirectiveName(c->getDKind());
             }
           OS << ")";  
           }
             }
       } 
     }
   OS << NL;
   if (!ForceNoStmt && S->hasAssociatedStmt())
     PrintStmt(S->getRawStmt());
 }
 
-void StmtPrinter::VisitOMPMetaDirective(OMPMetaDirective *Node) {
-  
+void StmtPrinter::VisitOMPMetaDirective(OMPMetaDirective *Node) {  
   Indent() << "#pragma omp metadirective";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPParallelDirective(OMPParallelDirective *Node) {
   Indent() << "#pragma omp parallel";
   PrintOMPExecutableDirective(Node);
 }

clang/lib/Parse/ParseOpenMP.cpp

 //===--- ParseOpenMP.cpp - OpenMP directives parsing ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file

 ///         simd' | 'teams distribute parallel for simd' | 'teams distribute
 ///         parallel for' | 'target teams' | 'target teams distribute' | 'target
 ///         teams distribute parallel for' | 'target teams distribute parallel
 ///         for simd' | 'target teams distribute simd' | 'masked' {clause}
 ///         annot_pragma_openmp_end
 ///
 StmtResult
 Parser::ParseOpenMPDeclarativeOrExecutableDirective(ParsedStmtContext StmtCtx) {
 // need to check about the following
-  static bool ReadDirectiveWithinMetadirective = false; // what is this?
+  static bool ReadDirectiveWithinMetadirective = false;
   if (!ReadDirectiveWithinMetadirective)
     assert(Tok.isOneOf(tok::annot_pragma_openmp, tok::annot_attr_openmp) &&
            "Not an OpenMP directive!");
   ParsingOpenMPDirectiveRAII DirScope(*this);
   ParenBraceBracketBalancer BalancerRAIIObj(*this);
   SmallVector<OMPClause *, 5> Clauses;
   SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>,
               llvm::omp::Clause_enumSize + 1>
case OMPD_metadirective: {
     // First iteration of parsing all clauses of metadirective.
     // This iteration only parses and collects all context selector ignoring the
     // associated directives.
     TentativeParsingAction TPA(*this);
     ASTContext &ASTContext = Actions.getASTContext();
 
     BalancedDelimiterTracker T(*this, tok::l_paren,
                                tok::annot_pragma_openmp_end);
                                
     while (Tok.isNot(tok::annot_pragma_openmp_end)) {
   
       OpenMPClauseKind CKind = Tok.isAnnotation()
                                    ? OMPC_unknown
                                    : getOpenMPClauseKind(PP.getSpelling(Tok));
                                    
       SourceLocation Loc = ConsumeToken();
 
       // Parse '('.
       if (T.expectAndConsume(diag::err_expected_lparen_after,
                              getOpenMPClauseName(CKind).data()))
         return Directive;
 
       OMPTraitInfo &TI = Actions.getASTContext().getNewOMPTraitInfo();
       if (CKind == OMPC_when) {
         // parse and get OMPTraitInfo to pass to the When clause
         parseOMPContextSelectors(Loc, TI);
         if (TI.Sets.size() == 0) {
           Diag(Tok, diag::err_omp_expected_context_selector) << "when clause";
           TPA.Commit();
           return Directive;
         }
 
         // Parse ':' // You have parsed the OpenMP Context in the meta directive 
         if (Tok.is(tok::colon))
           ConsumeAnyToken();
         else {
           Diag(Tok, diag::err_omp_expected_colon) << "when clause";
           TPA.Commit();
           return Directive;
         }
       } // if (CKind == OMPC_when)  statement ends
      
       // Skip Directive for now. We will parse directive in the second iteration
       // This need to be catched
       int paren = 0;
       while (Tok.isNot(tok::r_paren) || paren != 0) {
         if (Tok.is(tok::l_paren))
           paren++;
         if (Tok.is(tok::r_paren))
           paren--;
case OMPD_metadirective: {
     TPA.Revert();
     // End of the first iteration. Parser is reset to the start of metadirective
     
     TargetOMPContext OMPCtx(ASTContext, /* DiagUnknownTrait */ nullptr,
                             /* CurrentFunctionDecl */ nullptr,
                             ArrayRef<llvm::omp::TraitProperty>());
     
     // Array A will be used for sorting                        
     SmallVector<std::pair<unsigned, llvm::APInt>> A;
     
     // The function will get the score for each clause and sort it 
     // based on the score number
     
     getArrayVariantMatchForContext(VMIs, OMPCtx, A) ;          
                                     
     ParseScope OMPDirectiveScope(this, ScopeFlags); 
     Actions.StartOpenMPDSABlock(DKind, DirName, Actions.getCurScope(), Loc);  
     
     while(Tok.isNot(tok::annot_pragma_openmp_end)){
     
       OpenMPClauseKind CKind = Tok.isAnnotation()
                                    ? OMPC_unknown
                                    : getOpenMPClauseKind(PP.getSpelling(Tok));
                                    
       Actions.StartOpenMPClause(CKind);
       OMPClause *Clause = ParseOpenMPMetaDirectiveClause( DKind, CKind);
       
       FirstClauses[(unsigned) CKind].setInt(true);
       if (Clause) {
         FirstClauses[(unsigned) CKind].setPointer(Clause);
         Clauses.push_back(Clause);
       }// end of if statement 
       
       if (Tok.is(tok::comma))
         ConsumeToken();
       
       Actions.EndOpenMPClause();
       
       if (Tok.is(tok::r_paren))
         ConsumeAnyToken();  
           
    }// end of the while loop
    
    // End location of the directive
    EndLoc = Tok.getLocation();
    
    //Consume final annot_pragma_openmp_end
    ConsumeAnnotationToken();
    
    SmallVector<OMPClause *, 5> Clauses_new;
    unsigned count = 0;
          
    for ( auto &it1 : A){
     count = 0;
     for ( auto &it2 : Clauses){
       if ( count == it1.first ){
         Clauses_new.push_back(it2);
         break;
       } else count++;
     }
    }// end of the for loop
OMPClause *Parser::ParseOpenMPMetaDirectiveClause(OpenMPDirectiveKind DKind,
   // Check if clause is allowed for the given directive.
   if (CKind != OMPC_unknown &&
       !isAllowedClauseForDirective(DKind, CKind, getLangOpts().OpenMP)) {
     Diag(Tok, diag::err_omp_unexpected_clause)
         << getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);
     ErrorFound = true;
     WrongDirective = true;
   }
-
  // Check if clause is not allowed
  if (CKind == OMPC_unknown) {
     Diag(Tok, diag::err_omp_unexpected_clause)
         << getOpenMPClauseName(CKind) << "Unknown clause: Not allowed";
     ErrorFound = true;
     WrongDirective = true;
   }
   
-  
-  if (CKind == OMPC_default || CKind == OMPC_when) {
     SourceLocation Loc = ConsumeToken();
     SourceLocation DelimLoc;
     // Parse '('.
     BalancedDelimiterTracker T(*this, tok::l_paren,
                                tok::annot_pragma_openmp_end);
     if (T.expectAndConsume(diag::err_expected_lparen_after,
                            getOpenMPClauseName(CKind).data()))
       return nullptr;
 
     OMPTraitInfo &TI = Actions.getASTContext().getNewOMPTraitInfo();
+ 
     if (CKind == OMPC_when) {
       // parse and get condition expression to pass to the When clause
       parseOMPContextSelectors(Loc, TI);
 
       // Parse ':'
       if (Tok.is(tok::colon))
         ConsumeAnyToken();
       else {
if (Tok.isNot(tok::r_paren)) {
 
       DirKind = parseOpenMPDirectiveKind(*this);
       ConsumeToken();
       ParseScope OMPDirectiveScope(this, ScopeFlags);
       Actions.StartOpenMPDSABlock(DirKind, DirName, Actions.getCurScope(), Loc);
       
       int paren = 0;
       
-      while (Tok.isNot(tok::r_paren) || paren != 0) {
-        if (Tok.is(tok::l_paren))
           paren++;
-        if (Tok.is(tok::r_paren))
           paren--;
   
-        OpenMPClauseKind CKind = Tok.isAnnotation()
                                      ? OMPC_unknown
                                      : getOpenMPClauseKind(PP.getSpelling(Tok));
          
-        if (CKind == OMPC_unknown &&
           !isAllowedClauseForDirective(DirKind, CKind, getLangOpts().OpenMP)) {
         Diag(Tok, diag::err_omp_unexpected_clause)
             << getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);
         ErrorFound = true;
         WrongDirective = true;
-    }
+       }
         
                                
-        Actions.StartOpenMPClause(CKind);
 
-        OMPClause *Clause = ParseOpenMPClause(
             DirKind, CKind, !FirstClauses[(unsigned)CKind].getInt());
-        FirstClauses[(unsigned)CKind].setInt(true);
-        if (Clause) {
           FirstClauses[(unsigned)CKind].setPointer(Clause);
           Clauses.push_back(Clause);
-        }
-
-        // Skip ',' if any.
-        if (Tok.is(tok::comma))
           ConsumeToken();
-        Actions.EndOpenMPClause();
-        
-        
+      Actions.EndOpenMPClause();  
       }
-  
       Actions.ActOnOpenMPRegionStart(DirKind, getCurScope());
       ParsingOpenMPDirectiveRAII NormalScope(*this, /*Value=*/false);
-
       /* Get Stmt and revert back */
       TentativeParsingAction TPA(*this);
       while (Tok.isNot(tok::annot_pragma_openmp_end)) {
         ConsumeAnyToken();
       }
       
       ConsumeAnnotationToken();
       ParseScope InnerStmtScope(this, Scope::DeclScope,
                                 getLangOpts().C99 || getLangOpts().CPlusPlus,
                                 Tok.is(tok::l_brace));
                                                       
       StmtResult AStmt = ParseStatement();
       InnerStmtScope.Exit();
       TPA.Revert();
       /* End Get Stmt */
 
       AssociatedStmt = (Sema::CompoundScopeRAII(Actions), AStmt);
       AssociatedStmt = Actions.ActOnOpenMPRegionEnd(AssociatedStmt, Clauses);
-  
+      
       Directive = Actions.ActOnOpenMPExecutableDirective(
           DirKind, DirName, OMPD_unknown, llvm::makeArrayRef(Clauses),
           AssociatedStmt.get(), Loc, Tok.getLocation());
-  
-  
+          
       Actions.EndOpenMPDSABlock(Directive.get());
       OMPDirectiveScope.Exit();
- 
     }
-
     // Parse ')'
     T.consumeClose();
 
     if (WrongDirective)
       return nullptr;
 
     Clause = Actions.ActOnOpenMPWhenClause(TI, DirKind, Directive, Loc,
                                            DelimLoc, Tok.getLocation());
   } else {
     ErrorFound = false;
     Diag(Tok, diag::err_omp_unexpected_clause)
         << getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);     
   }
-    
+    
   return ErrorFound ? nullptr : Clause;
 }
 
-
-
 /// Parsing of OpenMP clauses.
 ///
 ///    clause:
 ///       if-clause | final-clause | num_threads-clause | safelen-clause |
 ///       default-clause | private-clause | firstprivate-clause | shared-clause
 ///       | linear-clause | aligned-clause | collapse-clause | bind-clause |
 ///       lastprivate-clause | reduction-clause | proc_bind-clause |
 ///       schedule-clause | copyin-clause | copyprivate-clause | untied-clause |

clang/lib/Sema/SemaOpenMP.cpp

 //===--- SemaOpenMP.cpp - Semantic Analysis for OpenMP constructs ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
if (isOpenMPWorksharingDirective(DKind))
     Traits.emplace_back(llvm::omp::TraitProperty::construct_for_for);
   if (isOpenMPSimdDirective(DKind))
     Traits.emplace_back(llvm::omp::TraitProperty::construct_simd_simd);
   Stack->handleConstructTrait(Traits, ScopeEntry);
 }
 
 void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) {
   switch (DKind) {
-  case OMPD_metadirective: // added
+  case OMPD_metadirective:
   case OMPD_parallel:
   case OMPD_parallel_for:
   case OMPD_parallel_for_simd:
   case OMPD_parallel_sections:
   case OMPD_parallel_master:
   case OMPD_teams:
   case OMPD_teams_distribute:
   case OMPD_teams_distribute_simd: {
void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) {
   case OMPD_declare_mapper:
   case OMPD_declare_simd:
   case OMPD_declare_target:
   case OMPD_end_declare_target:
   case OMPD_requires:
   case OMPD_declare_variant:
   case OMPD_begin_declare_variant:
   case OMPD_end_declare_variant:
-  //case OMPD_metadirective:
     //llvm_unreachable("OpenMP Directive is not allowed");
   case OMPD_unknown:
   default:
     llvm_unreachable("Unknown OpenMP directive");
   }
   DSAStack->setContext(CurContext);
   handleDeclareVariantConstructTrait(DSAStack, DKind, /* ScopeEntry */ true);
 }
if (Ordered && Order) {
     S.Diag(Ordered->getBeginLoc(), diag::note_omp_ordered_param)
         << 0 << SourceRange(Ordered->getBeginLoc(), Ordered->getEndLoc());
     return true;
   }
   return false;
 }
 
 StmtResult Sema::ActOnOpenMPRegionEnd(StmtResult S,
-                                      ArrayRef<OMPClause *> Clauses) {
-                                                                        
+                                      ArrayRef<OMPClause *> Clauses) {                                                        
   handleDeclareVariantConstructTrait(DSAStack, DSAStack->getCurrentDirective(),
                                      /* ScopeEntry */ false);
   if (DSAStack->getCurrentDirective() == OMPD_atomic ||
       DSAStack->getCurrentDirective() == OMPD_critical ||
       DSAStack->getCurrentDirective() == OMPD_section ||
       DSAStack->getCurrentDirective() == OMPD_master ||
       DSAStack->getCurrentDirective() == OMPD_masked)
     return S;
for (OpenMPDirectiveKind ThisCaptureRegion : llvm::reverse(CaptureRegions)) {
     }
     
     if (++CompletedRegions == CaptureRegions.size())
       DSAStack->setBodyComplete();
     
     SR = ActOnCapturedRegionEnd(SR.get());
     
   }
   
   return SR;
 }
 
 static bool checkCancelRegion(Sema &SemaRef, OpenMPDirectiveKind CurrentRegion,
                               OpenMPDirectiveKind CancelRegion,
                               SourceLocation StartLoc) {
   // CancelRegion is only needed for cancel and cancellation_point.
   if (CurrentRegion != OMPD_cancel && CurrentRegion != OMPD_cancellation_point)
if (AStmt && !CurContext->isDependentContext() && Kind != OMPD_atomic &&
     // mappers.
     if (LangOpts.OpenMP >= 50)
       processImplicitMapsWithDefaultMappers(*this, DSAStack,
                                             ClausesWithImplicit);
   }
 
   llvm::SmallVector<OpenMPDirectiveKind, 4> AllowedNameModifiers;
   switch (Kind) {
-
   case OMPD_metadirective:
     Res = ActOnOpenMPMetaDirective(ClausesWithImplicit, AStmt, StartLoc, 
               EndLoc);
     AllowedNameModifiers.push_back(OMPD_metadirective); 
     break;
   case OMPD_parallel:
     Res = ActOnOpenMPParallelDirective(ClausesWithImplicit, AStmt, StartLoc,
                                        EndLoc);
auto *NewAttr = OMPDeclareVariantAttr::CreateImplicit(
       Context, VariantRef, &TI, const_cast<Expr **>(AdjustArgsNothing.data()),
       AdjustArgsNothing.size(),
       const_cast<Expr **>(AdjustArgsNeedDevicePtr.data()),
       AdjustArgsNeedDevicePtr.size(),
       const_cast<OMPDeclareVariantAttr::InteropType *>(AppendArgs.data()),
       AppendArgs.size(), SR);
   FD->addAttr(NewAttr);
 }
-///
 
 StmtResult Sema::ActOnOpenMPMetaDirective(ArrayRef<OMPClause *> Clauses,
                                               Stmt *AStmt,
                                               SourceLocation StartLoc,
-                                              SourceLocation EndLoc) {
-                                              
+                                              SourceLocation EndLoc) {                                           
  if (!AStmt)
     return StmtError();
 
   auto *CS = cast<CapturedStmt>(AStmt);
-  // 
   CS->getCapturedDecl()->setNothrow();
 
   StmtResult IfStmt = StmtError();
   Stmt *ElseStmt = NULL;
 
   for (auto i = Clauses.rbegin(); i < Clauses.rend(); i++) {
     OMPWhenClause *WhenClause = dyn_cast<OMPWhenClause>(*i);
     Expr *WhenCondExpr = NULL;
for (const OMPTraitSet &Set : WhenClause->getTI().Sets) {
               if (T.getArchName() == Property.RawString) {
                 archMatch = true;
                 break;
               }
             }
             if (archMatch)
               break;
           }
           // Create a true/false boolean expression and assign to WhenCondExpr
           auto *C = new (Context)
               CXXBoolLiteralExpr(archMatch, Context.BoolTy, StartLoc);
           WhenCondExpr = dyn_cast<Expr>(C);
           break;
         }
         case TraitSelector::user_condition: {
           assert(Selector.ScoreOrCondition &&
                  "Ill-formed user condition, expected condition expression!");
for (const OMPTraitSet &Set : WhenClause->getTI().Sets) {
         }
         case TraitSelector::device_isa:
         case TraitSelector::device_kind:
         case TraitSelector::implementation_extension:
         default:
           break;
         }
       }
-    } ////
+    } 
 
     if (WhenCondExpr == NULL) {
       if (ElseStmt != NULL) {
         Diag(WhenClause->getBeginLoc(), diag::err_omp_misplaced_default_clause);
         return StmtError();
       }
       if (DKind == OMPD_unknown)
         ElseStmt = CompoundStmt::Create(Context, {CS->getCapturedStmt()},
                                         SourceLocation(), SourceLocation());
       else
         ElseStmt = ThenStmt;
       continue;
     }
 
     if (ThenStmt == NULL)
       ThenStmt = CompoundStmt::Create(Context, {CS->getCapturedStmt()},
                                       SourceLocation(), SourceLocation());
 
     IfStmt =
         ActOnIfStmt(SourceLocation(), /*false*/ IfStatementKind::Ordinary, SourceLocation(), NULL,
                     ActOnCondition(getCurScope(), SourceLocation(),
                                    WhenCondExpr, Sema::ConditionKind::Boolean),
                     SourceLocation(), ThenStmt, SourceLocation(), ElseStmt);
     ElseStmt = IfStmt.get();
   }
 
   return OMPMetaDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
-                                  IfStmt.get());
-                                              
+                                  IfStmt.get());                                         
 }
 
-
-///
 StmtResult Sema::ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
                                               Stmt *AStmt,
                                               SourceLocation StartLoc,
                                               SourceLocation EndLoc) {
   if (!AStmt)
     return StmtError();
 
   auto *CS = cast<CapturedStmt>(AStmt);
for (unsigned I = First; I < Last; ++I) {
     if (I + Skipped + 2 == Last)
       Out << " or ";
     else if (I + Skipped + 1 != Last)
       Out << ", ";
   }
   return std::string(Out.str());
 }
 
-/// ActOnOpenMPWheClause --- Abid
-
 OMPClause *
 Sema::ActOnOpenMPWhenClause(OMPTraitInfo &TI, OpenMPDirectiveKind DKind,
                             StmtResult Directive, SourceLocation StartLoc,
                             SourceLocation LParenLoc, SourceLocation EndLoc) {
   return new (Context)
       OMPWhenClause(TI, DKind, Directive.get(), StartLoc, LParenLoc, EndLoc);
 }
 
-
-
-
 OMPClause *Sema::ActOnOpenMPDefaultClause(DefaultKind Kind,
                                           SourceLocation KindKwLoc,
                                           SourceLocation StartLoc,
                                           SourceLocation LParenLoc,
                                           SourceLocation EndLoc) {
   if (Kind == OMP_DEFAULT_unknown) {
     Diag(KindKwLoc, diag::err_omp_unexpected_clause_value)
         << getListOfPossibleValues(OMPC_default, /*First=*/0,

clang/lib/Sema/SemaStmt.cpp

 //===--- SemaStmt.cpp - Semantic Analysis for Statements ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
StmtResult Sema::ActOnCapturedRegionEnd(Stmt *S) {
   CapturedDecl *CD = RSI->TheCapturedDecl;
   RecordDecl *RD = RSI->TheRecordDecl;
 
   CapturedStmt *Res = CapturedStmt::Create(
       getASTContext(), S, static_cast<CapturedRegionKind>(RSI->CapRegionKind),
       Captures, CaptureInits, CD, RD);
       
   CD->setBody(Res->getCapturedStmt());
-    
   RD->completeDefinition();
 
   return Res;
 }

llvm/include/llvm/Frontend/OpenMP/OMPContext.h

 //===- OpenMP/OMPContext.h ----- OpenMP context helper functions  - C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file

 /// Sort array \p A of clause index  with score
 /// This will be used to produce AST clauses
 /// in a sorted order with the clause with the highiest order
 /// on the top and default clause at the bottom
 void getArrayVariantMatchForContext(
     const SmallVectorImpl<VariantMatchInfo> &VMIs, const OMPContext &Ctx,
     SmallVector<std::pair<unsigned, APInt>> &A);
 
-// new--
 } // namespace omp
 
 template <> struct DenseMapInfo<omp::TraitProperty> {
   static inline omp::TraitProperty getEmptyKey() {
     return omp::TraitProperty(-1);
   }
   static inline omp::TraitProperty getTombstoneKey() {
     return omp::TraitProperty(-2);

llvm/lib/Frontend/OpenMP/OMPContext.cpp

 //===- OMPContext.cpp ------ Collection of helpers for OpenMP contexts ----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// This file implements helper functions and classes to deal with OpenMP
 /// contexts as used by `[begin/end] declare variant` and `metadirective`.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Frontend/OpenMP/OMPContext.h"
 #include "llvm/ADT/SetOperations.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
-
 #include <map>
 #define DEBUG_TYPE "openmp-ir-builder"
 
 using namespace llvm;
 using namespace omp;
 
 OMPContext::OMPContext(bool IsDeviceCompilation, Triple TargetTriple) {
   // Add the appropriate device kind trait based on the triple and the
for (TraitProperty Property : VMI.ConstructTraits) {
     Score += (1ULL << ConstructMatches[ConstructIdx++]);
   }
 
   LLVM_DEBUG(dbgs() << "[" << DEBUG_TYPE << "] Variant has a score of " << Score
                     << "\n");
   return Score;
 }
 
-/// 
 /// Takes \p VMI and \p Ctx and sort the 
 /// scores using \p A
 void llvm::omp::getArrayVariantMatchForContext(const SmallVectorImpl<VariantMatchInfo> &VMIs,
                                     const OMPContext &Ctx, SmallVector<std::pair<unsigned, APInt>> &A){
-  
-  //APInt BestScore(64, 0);
-  APInt Score (64, 0);
-  llvm::DenseMap<unsigned, llvm::APInt> m;
+   APInt Score (64, 0);
+   llvm::DenseMap<unsigned, llvm::APInt> m;
       
-  /*for (unsigned u = 0, e = VMIs.size(); u < e; ++u) {
-    const VariantMatchInfo &VMI = VMIs[u];
-    SmallVector<unsigned, 8> ConstructMatches;
-          APInt Score = getVariantMatchScore(VMI, Ctx, ConstructMatches);
-          m.insert({u, Score}); 
-  }
-
-  */
-  
-  for (unsigned u = 0, e = VMIs.size(); u < e; ++u) {
-        const VariantMatchInfo &VMI = VMIs[u];
+   for (unsigned u = 0, e = VMIs.size(); u < e; ++u) {
+      const VariantMatchInfo &VMI = VMIs[u];
 
-        SmallVector<unsigned, 8> ConstructMatches;
-        // If the variant is not applicable its not the best.
-        if (!isVariantApplicableInContextHelper(VMI, Ctx, &ConstructMatches,
+      SmallVector<unsigned, 8> ConstructMatches;
+      // If the variant is not applicable its not the best.
+    if (!isVariantApplicableInContextHelper(VMI, Ctx, &ConstructMatches,
                                             /* DeviceSetOnly */ false)){
-                       Score = 0;
-                       m.insert({u, Score});                    
-            continue;
-          }
+      continue;}
           
-      // Check if its clearly not the best.
-        Score = getVariantMatchScore(VMI, Ctx, ConstructMatches);
+      // Check if its clearly not the best.
+    Score = getVariantMatchScore(VMI, Ctx, ConstructMatches);
     m.insert({u, Score}); 
-  }
+   }
       
-  for (auto& it : m) 
-    A.push_back(it);
+   for (auto& it : m)   A.push_back(it);
   
-  std::sort(A.begin(), A.end(), [] (std::pair<unsigned, APInt>&a,
+   std::sort(A.begin(), A.end(), [] (std::pair<unsigned, APInt>&a,
            std::pair<unsigned, APInt>&b){  
-      return a.second.ugt(b.second);
-    }); 
+      return a.second.ugt(b.second);});  
 }
  
-
-
 int llvm::omp::getBestVariantMatchForContext(
     const SmallVectorImpl<VariantMatchInfo> &VMIs, const OMPContext &Ctx) {
 
   APInt BestScore(64, 0);
   int BestVMIIdx = -1;
   const VariantMatchInfo *BestVMI = nullptr;
 
   for (unsigned u = 0, e = VMIs.size(); u < e; ++u) {
     const VariantMatchInfo &VMI = VMIs[u];
 
     SmallVector<unsigned, 8> ConstructMatches;
     // If the variant is not applicable its not the best.
     if (!isVariantApplicableInContextHelper(VMI, Ctx, &ConstructMatches,
                                             /* DeviceSetOnly */ false))