Perform lvalue-to-rvalue conversion in shape expressions

Closes llvm#64

Author: mikaoP

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -10869,7 +10869,6 @@ def err_oss_wrong_dsa : Error<
   "%0 variable cannot be %1">;
 def err_oss_array_section_use : Error<"OmpSs-2 array section is not allowed here">;
 def err_oss_array_shaping_use : Error<"OmpSs-2 array shaping is not allowed here">;
-def err_oss_array_shaping_use_section : Error<"OmpSs-2 array section is not allowed in array shaping">;
 def err_oss_mismatch_depend_dsa : Error<
   "the data-sharing '%0' conflicts with '%1' required by the dependency">;
 def err_oss_not_defined_dsa_when_default_none : Error<

clang/lib/Sema/SemaExpr.cpp

@@ -5160,10 +5160,12 @@ ExprResult Sema::ActOnOSSArrayShapingExpr(Expr *Base, ArrayRef<Expr *> Shapes,
 
   if (!Base) {
     ErrorFound = true;
-  } else if (auto *OASE = dyn_cast<OSSArraySectionExpr>(Base->IgnoreParens())) {
-    Diag(OASE->getBeginLoc(), diag::err_oss_array_shaping_use_section)
-      << OASE->getSourceRange();
-    ErrorFound = true;
+  } else {
+    ExprResult Result = CheckPlaceholderExpr(Base);
+    if (Result.isInvalid()) {
+      Base = Result.get();
+      ErrorFound = true;
+    }
   }
 
   for (Expr *const &E : Shapes) {
@@ -5220,20 +5222,31 @@ ExprResult Sema::ActOnOSSArrayShapingExpr(Expr *Base, ArrayRef<Expr *> Shapes,
     ErrorFound = true;
   }
 
+  SmallVector<Expr *, 4> NewShapes;
   for (int i = Shapes.size() - 1 ; i >= 0; --i) {
-    auto Res = PerformOmpSsImplicitIntegerConversion(Shapes[i]->getExprLoc(),
-                                                     Shapes[i]);
+    Expr *NewShape = Shapes[i];
+    ExprResult Result = DefaultLvalueConversion(NewShape);
+    if (Result.isInvalid()) {
+      ErrorFound = true;
+      continue;
+    }
+    NewShape = Result.get();
+
+    auto Res = PerformOmpSsImplicitIntegerConversion(NewShape->getExprLoc(),
+                                                     NewShape);
     if (Res.isInvalid()) {
       ErrorFound = true;
       // FIXME: PerformContextualImplicitConversion doesn't always tell us if it
       // failed and produced a diagnostic.
       // From commit ef6c43dc
-      Diag(Shapes[i]->getExprLoc(), diag::err_oss_typecheck_shape_not_integer)
-                       << 0 << Shapes[i]->getSourceRange();
+      Diag(NewShape->getExprLoc(), diag::err_oss_typecheck_shape_not_integer)
+                       << 0 << NewShape->getSourceRange();
       continue;
     }
+    NewShape = Res.get();
+    NewShapes.insert(NewShapes.begin(), NewShape);
 
-    Type = BuildArrayType(Type, ArrayType::Normal, Res.get(), /*Quals=*/0,
+    Type = BuildArrayType(Type, ArrayType::Normal, NewShape, /*Quals=*/0,
                           Shapes[i]->getSourceRange(),
                           DeclarationName());
     if (Type.isNull())
@@ -5251,7 +5264,7 @@ ExprResult Sema::ActOnOSSArrayShapingExpr(Expr *Base, ArrayRef<Expr *> Shapes,
     return ExprError();
 
   return OSSArrayShapingExpr::Create(Context, Type,
-                                     VK_LValue, OK_Ordinary, Base, Shapes, LBLoc, RBLoc);
+                                     VK_LValue, OK_Ordinary, Base, NewShapes, LBLoc, RBLoc);
 }
 
 ExprResult Sema::ActOnOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc,

clang/test/OmpSs/AST/shape_non_odr_use.cpp

@@ -0,0 +1,22 @@
+// RUN: %clang_cc1 -verify -fompss-2 -ast-dump -ferror-limit 100 %s | FileCheck %s
+// expected-no-diagnostics
+
+struct S {
+    static constexpr int N = 4;
+};
+
+void foo(int *p) {
+    #pragma oss task in([S::N]p)
+    {}
+}
+
+// CHECK: OSSTaskDirective 0x{{.*}} <line:{{.*}}:{{.*}}, col:{{.*}}> ompss-2
+// CHECK-NEXT: OSSDependClause 0x{{.*}} <col:{{.*}}, col:{{.*}}> <oss syntax>
+// CHECK-NEXT: OSSArrayShapingExpr 0x{{.*}} <col:{{.*}}, col:{{.*}}> 'int [4]' lvalue
+// CHECK-NEXT: ImplicitCastExpr 0x{{.*}} <col:{{.*}}> 'int *' <LValueToRValue>
+// CHECK-NEXT: DeclRefExpr 0x{{.*}} <col:{{.*}}> 'int *' lvalue ParmVar 0x{{.*}} 'p' 'int *'
+// CHECK-NEXT: ImplicitCastExpr 0x{{.*}} <col:{{.*}}, col:{{.*}}> 'int' <LValueToRValue>
+// CHECK-NEXT: DeclRefExpr 0x{{.*}} <col:{{.*}}, col:{{.*}}> 'const int' lvalue Var 0x{{.*}} 'N' 'const int' non_odr_use_constant
+// CHECK-NEXT: OSSFirstprivateClause 0x{{.*}} <<invalid sloc>> <implicit>
+// CHECK-NEXT: DeclRefExpr 0x{{.*}} <col:{{.*}}> 'int *' lvalue ParmVar 0x{{.*}} 'p' 'int *'
+// CHECK-NEXT: DeclRefExpr 0x{{.*}} <col:{{.*}}, col:{{.*}}> 'const int' lvalue Var 0x{{.*}} 'N' 'const int' non_odr_use_constant

clang/test/OmpSs/AST/task_depend.cpp

@@ -104,6 +104,7 @@ void bar1() {
 // CHECK-NEXT: OSSArrayShapingExpr {{[a-z0-9]+}} <col:31, col:34> 'int [t][20]' lvalue
 // CHECK-NEXT: ImplicitCastExpr {{[a-z0-9]+}} <col:34> 'int (*)[20]' <ArrayToPointerDecay>
 // CHECK-NEXT: DeclRefExpr {{[a-z0-9]+}} <col:34> 'int [10][20]' lvalue Var {{[a-z0-9]+}} 'array' 'int [10][20]'
+// CHECK-NEXT: ImplicitCastExpr {{[a-z0-9]+}} <col:32> 'int':'int' <LValueToRValue>
 // CHECK-NEXT: DeclRefExpr {{[a-z0-9]+}} <col:32> 'int':'int' lvalue ParmVar {{[a-z0-9]+}} 't' 'int':'int'
 // CHECK-NEXT: OSSArrayShapingExpr {{[a-z0-9]+}} <col:41, col:50> 'int [1][2][3][20]' lvalue
 // CHECK-NEXT: ImplicitCastExpr {{[a-z0-9]+}} <col:50> 'int (*)[20]' <ArrayToPointerDecay>
@@ -121,6 +122,7 @@ void bar1() {
 // CHECK-NEXT: OSSArrayShapingExpr {{[a-z0-9]+}} <col:31, col:34> 'int [t]' lvalue
 // CHECK-NEXT: ImplicitCastExpr {{[a-z0-9]+}} <col:34> 'int *' <LValueToRValue>
 // CHECK-NEXT: DeclRefExpr {{[a-z0-9]+}} <col:34> 'int *' lvalue Var {{[a-z0-9]+}} 'p' 'int *'
+// CHECK-NEXT: ImplicitCastExpr {{[a-z0-9]+}} <col:32> 'int':'int' <LValueToRValue>
 // CHECK-NEXT: DeclRefExpr {{[a-z0-9]+}} <col:32> 'int':'int' lvalue ParmVar {{[a-z0-9]+}} 't' 'int':'int'
 // CHECK-NEXT: OSSArrayShapingExpr {{[a-z0-9]+}} <col:37, col:46> 'int [1][2][3]' lvalue
 // CHECK-NEXT: ImplicitCastExpr {{[a-z0-9]+}} <col:46> 'int *' <LValueToRValue>

clang/test/OmpSs/Parser/shaping_expr_vs_lambda.cpp

@@ -8,7 +8,7 @@ void foo1() {
   {}
   #pragma oss task depend(in: ([1][2][3]array)[4:5][5])
   {}
-  #pragma oss task depend(in: [1][2]array[4:5]) // expected-error {{OmpSs-2 array section is not allowed in array shaping}}
+  #pragma oss task depend(in: [1][2]array[4:5]) // expected-error {{OmpSs-2 array section is not allowed here}}
   {}
   #pragma oss task depend(in: [1][2 : 3]array) // expected-error {{expected ']'}} expected-note {{to match this '['}}
   {}

clang/test/OmpSs/Sema/task_depend_shaping_expr1.c

@@ -5,13 +5,13 @@ void foo() {
 {
     int p[10][20][3];
     int *p1;
-    #pragma oss task in([12](p[:])) // expected-error {{OmpSs-2 array section is not allowed in array shaping}}
+    #pragma oss task in([12](p[:])) // expected-error {{OmpSs-2 array section is not allowed here}}
     { }
     #pragma oss task in([[1]p]p) // expected-error {{OmpSs-2 array shaping is not allowed here}}
     { }
     #pragma oss task in([([1]p1)[:]]p)  // expected-error {{OmpSs-2 array shaping is not allowed here}}
     { }
-    #pragma oss task in([(p[0:1])]p) // expected-error {{OmpSs-2 array section is not allowed here}} expected-error {{array shape is not an integer}}
+    #pragma oss task in([(p[0:1])]p) // expected-error {{OmpSs-2 array section is not allowed here}}
     { }
     #pragma oss task in([]p) // expected-error {{expected expression}}
     { }