Adding support for clauses novariants and nocontext occuring on the same

dispatch directive.

Author: Sunil Kuravinakop

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -11899,9 +11899,6 @@ def err_omp_clause_requires_dispatch_construct : Error<
   "'%0' clause requires 'dispatch' context selector">;
 def err_omp_append_args_with_varargs : Error<
   "'append_args' is not allowed with varargs functions">;
-def warn_omp_dispatch_clause_novariants_nocontext : Warning<
-  "'nocontext' clause is ignored, only 'novariants' clause is applied">,
-  InGroup<SourceUsesOpenMP>;
 def err_openmp_vla_in_task_untied : Error<
   "variable length arrays are not supported in OpenMP tasking regions with 'untied' clause">;
 def warn_omp_unterminated_declare_target : Warning<

clang/lib/CodeGen/CGStmtOpenMP.cpp

@@ -4529,59 +4529,144 @@ void CodeGenFunction::EmitOMPMasterDirective(const OMPMasterDirective &S) {
   emitMaster(*this, S);
 }
 
-static Expr *replaceWithNewTraitsOrDirectCall(Stmt *AssocExpr,
-                                              CallExpr *ReplacementFunction) {
-  Expr *FinalCall = ReplacementFunction;
-
-  if (BinaryOperator *BinaryCopyOpr = dyn_cast<BinaryOperator>(AssocExpr)) {
-    BinaryCopyOpr->setRHS(FinalCall);
-    return BinaryCopyOpr;
+static Expr *replaceWithNewTraitsOrDirectCall(CapturedDecl *CDecl,
+                                              Expr *NewExpr) {
+  Expr *CurrentCallExpr = nullptr;
+  Stmt *CallExprStmt = CDecl->getBody();
+
+  if (BinaryOperator *BinaryCopyOpr = dyn_cast<BinaryOperator>(CallExprStmt)) {
+    CurrentCallExpr = BinaryCopyOpr->getRHS();
+    BinaryCopyOpr->setRHS(NewExpr);
+  } else {
+    CurrentCallExpr = dyn_cast<Expr>(CallExprStmt);
+    CDecl->setBody(NewExpr);
   }
 
-  return FinalCall;
+  return CurrentCallExpr;
 }
 
-static void transformCallInStmt(Stmt *StmtP) {
-  if (auto *AssocStmt = dyn_cast<CapturedStmt>(StmtP)) {
-    CapturedDecl *CDecl = AssocStmt->getCapturedDecl();
+static Expr *transformCallInStmt(Stmt *StmtP, bool NoContext = false) {
+  Expr *CurrentExpr = nullptr;
+  if (auto *CptStmt = dyn_cast<CapturedStmt>(StmtP)) {
+    CapturedDecl *CDecl = CptStmt->getCapturedDecl();
 
-    // Access AnnotateAttr
     CallExpr *NewCallExpr = nullptr;
     for (const auto *attr : CDecl->attrs()) {
-      if (const auto *annotateAttr = llvm::dyn_cast<clang::AnnotateAttr>(attr);
-          annotateAttr &&
-          annotateAttr->getAnnotation() == "NoContextInvariant") {
-        NewCallExpr = llvm::dyn_cast<CallExpr>(*annotateAttr->args_begin());
+      if (NoContext) {
+        if (const auto *annotateAttr =
+                llvm::dyn_cast<clang::AnnotateAttr>(attr);
+            annotateAttr && annotateAttr->getAnnotation() == "NoContextAttr") {
+          NewCallExpr = llvm::dyn_cast<CallExpr>(*annotateAttr->args_begin());
+        }
+      } else {
+        if (const auto *annotateAttr =
+                llvm::dyn_cast<clang::AnnotateAttr>(attr);
+            annotateAttr && annotateAttr->getAnnotation() == "NoVariantsAttr") {
+          NewCallExpr = llvm::dyn_cast<CallExpr>(*annotateAttr->args_begin());
+        }
       }
     }
 
-    Stmt *CallExprStmt = CDecl->getBody();
-    Stmt *NewCallExprStmt =
-        replaceWithNewTraitsOrDirectCall(CallExprStmt, NewCallExpr);
-    CDecl->setBody(NewCallExprStmt);
+    CurrentExpr = replaceWithNewTraitsOrDirectCall(CDecl, NewCallExpr);
   }
+  return CurrentExpr;
 }
 
-static void emitIfElse(CodeGenFunction *CGF, Expr *Condition,
-                       Stmt *AssociatedStmt) {
+// emitIfElse is used for the following conditions:
+//
+// NoVariants = 0 && NoContext = 1
+//   if (Condition_NoContext) {
+//     foo_variant2(); // Present in AnnotationAttr
+//   } else {
+//     foo_variant();
+//   }
+//
+// NoVariants = 1 && NoContext = 0
+//   if (Condition_NoVariants) {
+//     foo();
+//   } else {
+//     foo_variant();
+//   }
+//
+// NoVariants = 1 && NoContext = 1
+//   if (Condition_NoVariants) {   // ==> label if.then.NoVariants
+//     foo();
+//   } else {  // ==> label else.NoVariants
+//     if (Condition_NoContext) {   // ==> label if.then.NoContext
+//       foo_variant2(); // Present in AnnotationAttr
+//     } else {   // ==> label else
+//       foo_variant();
+//     }
+//   }
+//
+static void emitIfElse(CodeGenFunction *CGF, Stmt *AssociatedStmt,
+                       Expr *Condition_NoVariants, Expr *Condition_NoContext) {
   llvm::BasicBlock *ThenBlock = CGF->createBasicBlock("if.then");
   llvm::BasicBlock *ElseBlock = CGF->createBasicBlock("if.else");
   llvm::BasicBlock *MergeBlock = CGF->createBasicBlock("if.end");
+  llvm::BasicBlock *ThenNoVariantsBlock = nullptr;
+  llvm::BasicBlock *ElseNoVariantsBlock = nullptr;
+  llvm::BasicBlock *ThenNoContextBlock = nullptr;
+  Expr *ElseCall = nullptr;
 
-  CGF->EmitBranchOnBoolExpr(Condition, ThenBlock, ElseBlock, 0);
+  if (Condition_NoVariants && Condition_NoContext) {
+    ThenNoVariantsBlock = CGF->createBasicBlock("if.then.NoVariants");
+    ElseNoVariantsBlock = CGF->createBasicBlock("else.NoVariants");
+    ThenNoContextBlock = CGF->createBasicBlock("if.then.NoContext");
+
+    CGF->EmitBranchOnBoolExpr(Condition_NoVariants, ThenNoVariantsBlock,
+                              ElseNoVariantsBlock, 0);
+
+  } else if (Condition_NoVariants)
+    CGF->EmitBranchOnBoolExpr(Condition_NoVariants, ThenBlock, ElseBlock, 0);
+  else
+    CGF->EmitBranchOnBoolExpr(Condition_NoContext, ThenBlock, ElseBlock, 0);
+
+  if (Condition_NoVariants && Condition_NoContext) {
+    // Emit the NoVariants (if then, for the NoVariants)  block.
+    CGF->EmitBlock(ThenNoVariantsBlock);
+    Stmt *ThenStmt = AssociatedStmt;
+    ElseCall = transformCallInStmt(ThenStmt, false);
+    CGF->EmitStmt(ThenStmt);
+    CGF->Builder.CreateBr(MergeBlock);
+
+    CGF->EmitBlock(ElseNoVariantsBlock);
+    CGF->EmitBranchOnBoolExpr(Condition_NoVariants, ThenNoContextBlock,
+                              ElseBlock, 0);
+    // Emit the NoContext (else if, for the NoContext) block.
+    CGF->EmitBlock(ThenNoContextBlock);
+    Stmt *ThenNoContextStmt = AssociatedStmt;
+    transformCallInStmt(ThenNoContextStmt, true);
+    CGF->EmitStmt(ThenNoContextStmt);
+    CGF->Builder.CreateBr(MergeBlock);
+
+  } else if (Condition_NoVariants) {
+    // Emit the NoVariants (then) block.
+    CGF->EmitBlock(ThenBlock);
+    Stmt *ThenStmt = AssociatedStmt;
+    ElseCall = transformCallInStmt(ThenStmt, false);
+    CGF->EmitStmt(ThenStmt);
+    CGF->Builder.CreateBr(MergeBlock);
+
+  } else if (Condition_NoContext) {
+    // Emit the NoContext (then) block.
+    CGF->EmitBlock(ThenBlock);
+    Stmt *ThenStmt = AssociatedStmt;
+    ElseCall = transformCallInStmt(ThenStmt, true);
+    CGF->EmitStmt(ThenStmt);
+    CGF->Builder.CreateBr(MergeBlock);
+  }
 
   // Emit the else block.
-  Stmt *ElseStmt = AssociatedStmt;
   CGF->EmitBlock(ElseBlock);
+  Stmt *ElseStmt = AssociatedStmt;
+  if (auto *CaptStmt = dyn_cast<CapturedStmt>(ElseStmt)) {
+    CapturedDecl *CDecl = CaptStmt->getCapturedDecl();
+    replaceWithNewTraitsOrDirectCall(CDecl, ElseCall);
+  }
   CGF->EmitStmt(ElseStmt);
   CGF->Builder.CreateBr(MergeBlock);
 
-  // Emit the then block.
-  Stmt *ThenStmt = AssociatedStmt;
-  transformCallInStmt(ThenStmt);
-  CGF->EmitBlock(ThenBlock);
-  CGF->EmitStmt(ThenStmt);
-  CGF->Builder.CreateBr(MergeBlock);
   CGF->EmitBlock(MergeBlock);
 }
 
@@ -4598,25 +4683,32 @@ void CodeGenFunction::EmitOMPDispatchDirective(const OMPDispatchDirective &S) {
   if (!CapturedStmtInfo)
     CapturedStmtInfo = &CapStmtInfo;
 
+  Expr *NoVariantsCondition = nullptr;
+  Expr *NoContextCondition = nullptr;
   if (!Clauses.empty()) {
     if (S.hasClausesOfKind<OMPDependClause>())
       EmitOMPDispatchToTaskwaitDirective(S);
 
     if (S.hasClausesOfKind<OMPNovariantsClause>() ||
         S.hasClausesOfKind<OMPNocontextClause>()) {
-      Expr *Condition = nullptr;
       if (const OMPNovariantsClause *NoVariantsC =
               OMPExecutableDirective::getSingleClause<OMPNovariantsClause>(
                   Clauses)) {
-        Condition = NoVariantsC->getCondition();
+        NoVariantsCondition = NoVariantsC->getCondition();
+        if (const OMPNocontextClause *NoContextC =
+                OMPExecutableDirective::getSingleClause<OMPNocontextClause>(
+                    Clauses)) {
+          NoContextCondition = NoContextC->getCondition();
+        }
       } else {
         const OMPNocontextClause *NoContextC =
             OMPExecutableDirective::getSingleClause<OMPNocontextClause>(
                 Clauses);
-        Condition = NoContextC->getCondition();
+        NoContextCondition = NoContextC->getCondition();
       }
+
       OMPLexicalScope Scope(*this, S, OMPD_dispatch);
-      emitIfElse(this, Condition, AssociatedStmt);
+      emitIfElse(this, AssociatedStmt, NoVariantsCondition, NoContextCondition);
     }
   } else
     EmitStmt(AssociatedStmt);

clang/lib/Sema/SemaOpenMP.cpp

@@ -6030,6 +6030,28 @@ static Expr *getNewTraitsOrDirectCall(const ASTContext &Context,
   return FinalCall;
 }
 
+// Add Attribute NoContextAttr or NoVariantsAttr
+// to the CapturedDecl.
+static void addAttr(const ASTContext &Context, Expr *AssocExpr,
+                    SemaOpenMP *SemaPtr, bool NoContext, CapturedDecl *CDecl) {
+  llvm::SmallVector<Expr *, 4> Args;
+  Expr *NewCallExpr = nullptr;
+
+  if (NoContext) {
+    NewCallExpr = getNewTraitsOrDirectCall(Context, AssocExpr, SemaPtr, true);
+    Args.push_back(NewCallExpr);
+    CDecl->addAttr(AnnotateAttr::CreateImplicit(
+        const_cast<ASTContext &>(Context), "NoContextAttr", Args.data(),
+        Args.size()));
+  } else {
+    NewCallExpr = getNewTraitsOrDirectCall(Context, AssocExpr, SemaPtr, false);
+    Args.push_back(NewCallExpr);
+    CDecl->addAttr(AnnotateAttr::CreateImplicit(
+        const_cast<ASTContext &>(Context), "NoVariantsAttr", Args.data(),
+        Args.size()));
+  }
+}
+
 /// annotateAStmt() function is used by ActOnOpenMPExecutableDirective()
 /// for the dispatch directive (nocontext or invariant clauses).
 /// An annotation "NoContextInvariant" is added to the Captured Decl
@@ -6049,24 +6071,20 @@ void SemaOpenMP::annotateAStmt(const ASTContext &Context, Stmt *StmtP,
     Stmt *AssocExprStmt = AssocStmt->getCapturedStmt();
     CapturedDecl *CDecl = AssocStmt->getCapturedDecl();
     auto *AssocExpr = dyn_cast<Expr>(AssocExprStmt);
-    bool NoContext = false;
 
     if (OMPExecutableDirective::getSingleClause<OMPNovariantsClause>(Clauses)) {
-
-      if (OMPExecutableDirective::getSingleClause<OMPNocontextClause>(Clauses))
-        Diag(StartLoc, diag::warn_omp_dispatch_clause_novariants_nocontext);
+      addAttr(const_cast<ASTContext &>(Context), AssocExpr, SemaPtr, false,
+              CDecl);
+      if (OMPExecutableDirective::getSingleClause<OMPNocontextClause>(
+              Clauses)) {
+        addAttr(const_cast<ASTContext &>(Context), AssocExpr, SemaPtr, true,
+                CDecl);
+      }
     } else if (OMPExecutableDirective::getSingleClause<OMPNocontextClause>(
-                   Clauses))
-      NoContext = true;
-
-    Expr *NewCallExpr =
-        getNewTraitsOrDirectCall(Context, AssocExpr, SemaPtr, NoContext);
-    // Annotate "NoContextInvariant" to CDecl of the AssocStmt
-    llvm::SmallVector<Expr *, 4> Args;
-    Args.push_back(NewCallExpr);
-    CDecl->addAttr(AnnotateAttr::CreateImplicit(
-        const_cast<ASTContext &>(Context), "NoContextInvariant", Args.data(),
-        Args.size()));
+                   Clauses)) {
+      addAttr(const_cast<ASTContext &>(Context), AssocExpr, SemaPtr, true,
+              CDecl);
+    }
   }
 }