Support data-sharings deduced from depend clause

mikaoP · mikaoP · commit 118e8a7ae568 · 2018-11-26T12:05:25.000Z
Closes llvm#8
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -9494,6 +9494,8 @@ def err_oss_depend_weak_required : Error<
  "expected 'weak' clause">;
 def err_oss_wrong_dsa : Error<
   "%0 variable cannot be %1">;
+def err_oss_mismatch_depend_dsa : Error<
+  "the data-sharing '%0' conflicts with '%1' required by the dependency">;
 
 def err_oss_expected_addressable_lvalue_or_array_item : Error<
   "expected addressable lvalue expression, array element or array section">;
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
@@ -9306,6 +9306,11 @@ class Sema {
   /// Called on end of data sharing attribute block.
   void EndOmpSsDSABlock(Stmt *CurDirective);
 
+  // Check if there are conflicts between depend() and other DSA clauses
+  // This must happen before parsing the statement (if any) so child tasks
+  // can see DSA derived from 'depend' clauses
+  void ActOnOmpSsAfterClauseGathering(ArrayRef<OSSClause *> Clauses);
+
   StmtResult ActOnOmpSsExecutableDirective(ArrayRef<OSSClause *> Clauses,
       OmpSsDirectiveKind Kind, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc);
 
diff --git a/clang/lib/Parse/ParseOmpSs.cpp b/clang/lib/Parse/ParseOmpSs.cpp
@@ -91,6 +91,8 @@ StmtResult Parser::ParseOmpSsDeclarativeOrExecutableDirective(
     // Consume final annot_pragma_openmp_end.
     ConsumeAnnotationToken();
 
+    Actions.ActOnOmpSsAfterClauseGathering(Clauses);
+
     StmtResult AssociatedStmt;
     if (HasAssociatedStatement) {
       AssociatedStmt = (Sema::CompoundScopeRAII(Actions), ParseStatement());
diff --git a/clang/lib/Sema/SemaOmpSs.cpp b/clang/lib/Sema/SemaOmpSs.cpp
@@ -357,6 +357,79 @@ class DSAAttrChecker final : public StmtVisitor<DSAAttrChecker, void> {
   DSAAttrChecker(DSAStackTy *S, Sema &SemaRef, Stmt *CS)
       : Stack(S), SemaRef(SemaRef), ErrorFound(false), CS(CS) {}
 };
+
+class OSSClauseDSAChecker final : public StmtVisitor<OSSClauseDSAChecker, void> {
+  DSAStackTy *Stack;
+  Sema &SemaRef;
+  bool ErrorFound = false;
+public:
+  void VisitDeclRefExpr(DeclRefExpr *E) {
+    if (E->isTypeDependent() || E->isValueDependent() ||
+        E->containsUnexpandedParameterPack() || E->isInstantiationDependent())
+      return;
+
+    if (auto *VD = dyn_cast<VarDecl>(E->getDecl())) {
+      VD = VD->getCanonicalDecl();
+      // inout(x)              | shared(x)        | int x;
+      // inout(p[i])           | firstprivate(p)  | int *p;
+      // inout(a[i])           | shared(a)        | int a[N];
+      // inout(*p)/inout(p[0]) | firstprivate(p)  | int *p;
+      // inout(s.x)            | shared(s)        | struct S s;
+      // inout(ps->x)          | firstprivate(ps) | struct S *ps;
+      OmpSsClauseKind VKind = OSSC_shared;
+      if (VD->getType()->isPointerType())
+        VKind = OSSC_firstprivate;
+
+      SourceLocation ELoc = E->getExprLoc();
+      SourceRange ERange = E->getSourceRange();
+
+      DSAStackTy::DSAVarData DVarCurrent = Stack->getCurrentDSA(VD);
+      switch (DVarCurrent.CKind) {
+      case OSSC_shared:
+        if (VKind == OSSC_private || VKind == OSSC_firstprivate) {
+          ErrorFound = true;
+          SemaRef.Diag(ELoc, diag::err_oss_mismatch_depend_dsa)
+            << getOmpSsClauseName(DVarCurrent.CKind)
+            << getOmpSsClauseName(VKind) << ERange;
+        }
+        break;
+      case OSSC_private:
+      case OSSC_firstprivate:
+        if (VKind == OSSC_shared) {
+          ErrorFound = true;
+          SemaRef.Diag(ELoc, diag::err_oss_mismatch_depend_dsa)
+            << getOmpSsClauseName(DVarCurrent.CKind)
+            << getOmpSsClauseName(VKind) << ERange;
+        }
+        break;
+      default:
+        // OK: no DSA explicit, record DSA as explicit, but do not
+        // make a node for it
+        Stack->addDSA(VD, E, VKind, false);
+        break;
+      }
+    }
+  }
+
+  void VisitOSSDepend(OSSDependClause *Clause) {
+    for (Stmt *Child : Clause->children()) {
+      if (Child)
+        Visit(Child);
+    }
+  }
+
+  void VisitStmt(Stmt *S) {
+    for (Stmt *C : S->children()) {
+      if (C)
+        Visit(C);
+    }
+  }
+
+  bool isErrorFound() const { return ErrorFound; }
+
+  OSSClauseDSAChecker(DSAStackTy *S, Sema &SemaRef)
+      : Stack(S), SemaRef(SemaRef), ErrorFound(false) {}
+};
 } // namespace
 
 void Sema::InitDataSharingAttributesStackOmpSs() {
@@ -400,10 +473,19 @@ getListOfPossibleValues(OmpSsClauseKind K, unsigned First, unsigned Last,
   return Out.str();
 }
 
+void Sema::ActOnOmpSsAfterClauseGathering(ArrayRef<OSSClause *> Clauses) {
+  OSSClauseDSAChecker OSSDependChecker(DSAStack, *this);
+  for (auto *Clause : Clauses) {
+    if (Clause->getClauseKind() == OSSC_depend)
+      OSSDependChecker.VisitOSSDepend(cast<OSSDependClause> (Clause));
+  }
+}
+
 StmtResult Sema::ActOnOmpSsExecutableDirective(ArrayRef<OSSClause *> Clauses,
     OmpSsDirectiveKind Kind, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {
 
   bool ErrorFound = false;
+
   llvm::SmallVector<OSSClause *, 8> ClausesWithImplicit;
   ClausesWithImplicit.append(Clauses.begin(), Clauses.end());
   if (AStmt) {
@@ -412,7 +494,7 @@ StmtResult Sema::ActOnOmpSsExecutableDirective(ArrayRef<OSSClause *> Clauses,
     Stmt *S = AStmt;
     DSAChecker.Visit(S);
     if (DSAChecker.isErrorFound())
-      return StmtError();
+      ErrorFound = true;
 
     SmallVector<Expr *, 4> ImplicitShared(
         DSAChecker.getImplicitShared().begin(),
diff --git a/clang/test/OmpSs/task_depend_ast.c b/clang/test/OmpSs/task_depend_ast.c
@@ -19,3 +19,71 @@ int main() {
 // CHECK-NEXT: UnaryOperator {{[a-z0-9]+}} <col:{{[0-9]+}}, col:{{[0-9]+}}> 'int' lvalue prefix '*' cannot overflow
 // CHECK-NEXT: ImplicitCastExpr {{[a-z0-9]+}} <col:{{[0-9]+}}> 'int *' <LValueToRValue>
 // CHECK-NEXT: DeclRefExpr {{[a-z0-9]+}} <col:{{[0-9]+}}> 'int *' lvalue Var {{[a-z0-9]+}} 'c' 'int *
+
+int *p;
+int foo() {
+  #pragma oss task depend(inout: *p)
+  {
+    #pragma oss task
+    {
+      *p = 0;
+    }
+  }
+  return 0;
+}
+
+// CHECK: OSSTaskDirective {{[a-z0-9]+}} <line:{{[a-z0-9]+}}:{{[a-z0-9]+}}, col:{{[a-z0-9]+}}>
+// CHECK-NEXT: OSSDependClause {{[a-z0-9]+}} <col:{{[a-z0-9]+}}, col:{{[a-z0-9]+}}>
+// CHECK-NEXT: UnaryOperator {{[a-z0-9]+}} <col:{{[a-z0-9]+}}, col:{{[a-z0-9]+}}> 'int' lvalue prefix '*' cannot overflow
+// CHECK-NEXT: ImplicitCastExpr {{[a-z0-9]+}} <col:{{[a-z0-9]+}}> 'int *' <LValueToRValue>
+// CHECK-NEXT: DeclRefExpr {{[a-z0-9]+}} <col:{{[a-z0-9]+}}> 'int *' lvalue Var {{[a-z0-9]+}} 'p' 'int *'
+// CHECK-NEXT: CompoundStmt {{[a-z0-9]+}} <line:{{[a-z0-9]+}}:{{[a-z0-9]+}}, line:{{[a-z0-9]+}}:{{[a-z0-9]+}}>
+// CHECK-NEXT: OSSTaskDirective {{[a-z0-9]+}} <line:{{[a-z0-9]+}}:{{[a-z0-9]+}}, col:{{[a-z0-9]+}}>
+// CHECK-NEXT: OSSFirstprivateClause {{[a-z0-9]+}} <<invalid sloc>> <implicit>
+// CHECK-NEXT: DeclRefExpr {{[a-z0-9]+}} <line:{{[a-z0-9]+}}:{{[a-z0-9]+}}> 'int *' lvalue Var {{[a-z0-9]+}} 'p' 'int *'
+
+int array[5];
+int foo1() {
+  #pragma oss task depend(inout: array[2])
+  {
+    #pragma oss task
+    {
+      array[2] = 0;
+    }
+  }
+  return 0;
+}
+
+// CHECK: OSSTaskDirective {{[a-z0-9]+}} <line:{{[a-z0-9]+}}:{{[a-z0-9]+}}, col:{{[a-z0-9]+}}>
+// CHECK-NEXT: OSSDependClause {{[a-z0-9]+}} <col:{{[a-z0-9]+}}, col:{{[a-z0-9]+}}>
+// CHECK-NEXT: ArraySubscriptExpr {{[a-z0-9]+}} <col:{{[a-z0-9]+}}, col:{{[a-z0-9]+}}> 'int' lvalue
+// CHECK-NEXT: ImplicitCastExpr {{[a-z0-9]+}} <col:{{[a-z0-9]+}}> 'int *' <ArrayToPointerDecay>
+// CHECK-NEXT: DeclRefExpr {{[a-z0-9]+}} <col:{{[a-z0-9]+}}> 'int [5]' lvalue Var {{[a-z0-9]+}} 'array' 'int [5]'
+// CHECK-NEXT: IntegerLiteral {{[a-z0-9]+}} <col:{{[a-z0-9]+}}> 'int' 2
+// CHECK-NEXT: CompoundStmt {{[a-z0-9]+}} <line:{{[a-z0-9]+}}:{{[a-z0-9]+}}, line:{{[a-z0-9]+}}:{{[a-z0-9]+}}>
+// CHECK-NEXT: OSSTaskDirective {{[a-z0-9]+}} <line:{{[a-z0-9]+}}:{{[a-z0-9]+}}, col:{{[a-z0-9]+}}>
+// CHECK-NEXT: OSSSharedClause {{[a-z0-9]+}} <<invalid sloc>> <implicit>
+// CHECK-NEXT: DeclRefExpr {{[a-z0-9]+}} <line:{{[a-z0-9]+}}:{{[a-z0-9]+}}> 'int [5]' lvalue Var {{[a-z0-9]+}} 'array' 'int [5]'
+
+int foo2() {
+  int array[5];
+  #pragma oss task depend(inout: array[2])
+  {
+    #pragma oss task
+    {
+      array[2] = 0;
+    }
+  }
+  return 0;
+}
+
+// CHECK: OSSTaskDirective {{[a-z0-9]+}} <line:{{[a-z0-9]+}}:{{[a-z0-9]+}}, col:{{[a-z0-9]+}}>
+// CHECK-NEXT: OSSDependClause {{[a-z0-9]+}} <col:{{[a-z0-9]+}}, col:{{[a-z0-9]+}}>
+// CHECK-NEXT: ArraySubscriptExpr {{[a-z0-9]+}} <col:{{[a-z0-9]+}}, col:{{[a-z0-9]+}}> 'int' lvalue
+// CHECK-NEXT: ImplicitCastExpr {{[a-z0-9]+}} <col:{{[a-z0-9]+}}> 'int *' <ArrayToPointerDecay>
+// CHECK-NEXT: DeclRefExpr {{[a-z0-9]+}} <col:{{[a-z0-9]+}}> 'int [5]' lvalue Var {{[a-z0-9]+}} 'array' 'int [5]'
+// CHECK-NEXT: IntegerLiteral {{[a-z0-9]+}} <col:{{[a-z0-9]+}}> 'int' 2
+// CHECK-NEXT: CompoundStmt {{[a-z0-9]+}} <line:{{[a-z0-9]+}}:{{[a-z0-9]+}}, line:{{[a-z0-9]+}}:{{[a-z0-9]+}}>
+// CHECK-NEXT: OSSTaskDirective {{[a-z0-9]+}} <line:{{[a-z0-9]+}}:{{[a-z0-9]+}}, col:{{[a-z0-9]+}}>
+// CHECK-NEXT: OSSFirstprivateClause {{[a-z0-9]+}} <<invalid sloc>> <implicit>
+// CHECK-NEXT: DeclRefExpr {{[a-z0-9]+}} <line:{{[a-z0-9]+}}:{{[a-z0-9]+}}> 'int [5]' lvalue Var {{[a-z0-9]+}} 'array' 'int [5]'
diff --git a/clang/test/OmpSs/task_depend_dsa_conflict.cpp b/clang/test/OmpSs/task_depend_dsa_conflict.cpp
@@ -0,0 +1,25 @@
+// RUN: %clang_cc1 -verify -fompss-2 -ferror-limit 100 -o - -std=c++11 %s
+
+struct S {
+  int x;
+};
+
+int array[5];
+
+int main() {
+  S s;
+  S *ps;
+
+  int i;
+  int *p;
+  #pragma oss task private(i) depend(inout: i) // expected-error {{the data-sharing 'private' conflicts with 'shared' required by the dependency}}
+  #pragma oss task depend(inout: i) private(i) // expected-error {{the data-sharing 'private' conflicts with 'shared' required by the dependency}}
+  #pragma oss task firstprivate(i) depend(inout: i) // expected-error {{the data-sharing 'firstprivate' conflicts with 'shared' required by the dependency}}
+  #pragma oss task shared(p) depend(inout: p[2]) // expected-error {{the data-sharing 'shared' conflicts with 'firstprivate' required by the dependency}}
+  #pragma oss task shared(p) depend(inout: *p) // expected-error {{the data-sharing 'shared' conflicts with 'firstprivate' required by the dependency}}
+  #pragma oss task firstprivate(array) depend(inout: array[2]) // expected-error {{the data-sharing 'firstprivate' conflicts with 'shared' required by the dependency}}
+  #pragma oss task firstprivate(s) depend(inout: s.x) // expected-error {{the data-sharing 'firstprivate' conflicts with 'shared' required by the dependency}}
+  #pragma oss task shared(ps) depend(inout: ps->x) // expected-error {{the data-sharing 'shared' conflicts with 'firstprivate' required by the dependency}}
+  {}
+}
+
