CodeGen: Support OSSArraySections. Now last dimension matches array size instead of being 1

Author: mikaoP

clang/lib/CodeGen/CGOmpSsRuntime.cpp

@@ -116,6 +116,112 @@ class OSSDependVisitor
     FillBaseExprDimsAndType(E);
   }
 
+  void VisitOSSArraySectionExpr(const OSSArraySectionExpr *E) {
+    // Get Base Type
+    // An array section is considered a built-in type
+    BaseElementTy = OSSArraySectionExpr::getBaseOriginalType(
+                          E->getBase()->IgnoreParenImpCasts())
+                          .getCanonicalType();
+    if (BaseElementTy->isArrayType()) {
+      if (const ConstantArrayType *BaseArrayTy = CGF.getContext().getAsConstantArrayType(BaseElementTy)){
+        BaseElementTy = CGF.getContext().getBaseElementType(BaseElementTy);
+      } else if (const VariableArrayType *BaseArrayTy = CGF.getContext().getAsVariableArrayType(BaseElementTy)){
+        BaseElementTy = CGF.getContext().getBaseElementType(BaseElementTy);
+      } else {
+        llvm_unreachable("Unhandled array type");
+      }
+    }
+    // Get the inner expr
+    const Expr *TmpE = E;
+    // First come OSSArraySection
+    while (const OSSArraySectionExpr *ASE = dyn_cast<OSSArraySectionExpr>(TmpE->IgnoreParenImpCasts())) {
+      TmpE = ASE->getBase();
+      // Add indexes
+      llvm::Value *Idx, *IdxEnd;
+
+      const Expr *LowerB = ASE->getLowerBound();
+      if (LowerB)
+        Idx = CGF.EmitScalarExpr(LowerB);
+      else
+      // OpenMP 5.0 2.1.5 When the lower-bound is absent it defaults to 0.
+        Idx = llvm::ConstantInt::getSigned(OSSArgTy, 0);
+      Idx = CGF.Builder.CreateSExt(Idx, OSSArgTy);
+
+      const Expr *Size = ASE->getLength();
+      if (Size) {
+        IdxEnd = CGF.EmitScalarExpr(Size);
+        IdxEnd = CGF.Builder.CreateSExt(IdxEnd, OSSArgTy);
+        IdxEnd = CGF.Builder.CreateAdd(Idx, IdxEnd);
+      } else if (ASE->getColonLoc().isInvalid()) {
+        assert(!Size);
+        // OSSArraySection without ':' are regular array subscripts
+        IdxEnd = CGF.Builder.CreateAdd(Idx, llvm::ConstantInt::getSigned(OSSArgTy, 1));
+      } else {
+        // array[lower : ] -> [lower, dimsize)
+
+        // OpenMP 5.0 2.1.5
+        // When the length is absent it defaults to ⌈(size - lowerbound)∕stride⌉,
+        // where size is the size of the array dimension.
+        QualType BaseOriginalTy =
+          OSSArraySectionExpr::getBaseOriginalType(ASE->getBase());
+
+        if (const ConstantArrayType *BaseArrayTy = CGF.getContext().getAsConstantArrayType(BaseOriginalTy)) {
+          uint64_t DimSize = BaseArrayTy->getSize().getSExtValue();
+          IdxEnd = llvm::ConstantInt::getSigned(OSSArgTy, DimSize);
+        } else if (const VariableArrayType *BaseArrayTy = CGF.getContext().getAsVariableArrayType(BaseOriginalTy)) {
+          auto VlaSize = CGF.getVLAElements1D(BaseArrayTy);
+          IdxEnd = CGF.Builder.CreateSExt(VlaSize.NumElts, OSSArgTy);
+        } else {
+          llvm_unreachable("Unhandled array type");
+        }
+      }
+      IdxEnd = CGF.Builder.CreateSExt(IdxEnd, OSSArgTy);
+
+      Starts.push_back(Idx);
+      Ends.push_back(IdxEnd);
+      if (TmpE->IgnoreParenImpCasts()->getType()->isPointerType())
+        break;
+    }
+    while (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(TmpE->IgnoreParenImpCasts())) {
+      TmpE = ASE->getBase();
+      // Add indexes
+      llvm::Value *Idx = CGF.EmitScalarExpr(ASE->getIdx());
+      Idx = CGF.Builder.CreateSExt(Idx, OSSArgTy);
+      llvm::Value *IdxEnd = CGF.Builder.CreateAdd(Idx, llvm::ConstantInt::getSigned(OSSArgTy, 1));
+      Starts.push_back(Idx);
+      Ends.push_back(IdxEnd);
+      if (TmpE->IgnoreParenImpCasts()->getType()->isPointerType())
+        break;
+    }
+
+    Ptr = CGF.EmitScalarExpr(TmpE);
+
+    TmpE = TmpE->IgnoreParenImpCasts();
+
+    QualType TmpTy = TmpE->getType();
+    // Add Dimensions
+    if (TmpTy->isPointerType()) {
+      // T *
+      Dims.push_back(llvm::ConstantInt::getSigned(OSSArgTy, 1));
+    } else {
+      while (TmpTy->isArrayType()) {
+        // T []
+        if (const ConstantArrayType *BaseArrayTy = CGF.getContext().getAsConstantArrayType(TmpTy)) {
+          uint64_t DimSize = BaseArrayTy->getSize().getSExtValue();
+          Dims.push_back(llvm::ConstantInt::getSigned(OSSArgTy, DimSize));
+          TmpTy = BaseArrayTy->getElementType();
+        } else if (const VariableArrayType *BaseArrayTy = CGF.getContext().getAsVariableArrayType(TmpTy)) {
+          auto VlaSize = CGF.getVLAElements1D(BaseArrayTy);
+          llvm::Value *DimExpr = CGF.Builder.CreateSExt(VlaSize.NumElts, OSSArgTy);
+          Dims.push_back(DimExpr);
+          TmpTy = BaseArrayTy->getElementType();
+        } else {
+          llvm_unreachable("Unhandled array type");
+        }
+      }
+    }
+  }
+
   void VisitArraySubscriptExpr(const ArraySubscriptExpr *E) {
     // Get Base Type
     BaseElementTy = E->getType();

clang/test/OmpSs/IR/task_depend_array_section.c

@@ -0,0 +1,32 @@
+// RUN: %clang_cc1 -verify -fompss-2 -disable-llvm-passes -ferror-limit 100 %s -S -emit-llvm -o - | FileCheck %s
+// expected-no-diagnostics
+
+typedef int* Pointer;
+
+void foo(int x) {
+    Pointer aFix[10][10];
+    int aVLA[x][7];
+    #pragma oss task depend(in : aFix[:], aFix[1:], aFix[: 2], aFix[3 : 4])
+    #pragma oss task depend(in : aFix[5][:], aFix[5][1:], aFix[5][: 2], aFix[5][3 : 4])
+    #pragma oss task depend(in : aVLA[:], aVLA[1:], aVLA[: 2], aVLA[3 : 4])
+    #pragma oss task depend(in : aVLA[5][:], aVLA[5][1:], aVLA[5][: 2], aVLA[5][3 : 4])
+    {}
+}
+
+// CHECK: %x.addr = alloca i32, align 4
+// CHECK-NEXT: %aFix = alloca [10 x [10 x i32*]], align 16
+// CHECK-NEXT: %saved_stack = alloca i8*, align 8
+// CHECK-NEXT: %__vla_expr0 = alloca i64, align 8
+// CHECK-NEXT: store i32 %x, i32* %x.addr, align 4
+// CHECK-NEXT: %0 = load i32, i32* %x.addr, align 4 
+// CHECK-NEXT: %1 = zext i32 %0 to i64 
+// CHECK-NEXT: %2 = call i8* @llvm.stacksave() 
+// CHECK-NEXT: store i8* %2, i8** %saved_stack, align 8 
+// CHECK-NEXT: %vla = alloca [7 x i32], i64 %1, align 16 
+// CHECK-NEXT: store i64 %1, i64* %__vla_expr0, align 8 
+// CHECK: %3 = call token @llvm.directive.region.entry() [ "DIR.OSS"([5 x i8] c"TASK\00"), "QUAL.OSS.SHARED"([10 x [10 x i32*]]* %aFix), "QUAL.OSS.DEP.IN"([10 x i32*]* %arraydecay, i64 80, i64 0, i64 80, i64 10, i64 0, i64 10), "QUAL.OSS.DEP.IN"([10 x i32*]* %arraydecay1, i64 80, i64 0, i64 80, i64 10, i64 1, i64 10), "QUAL.OSS.DEP.IN"([10 x i32*]* %arraydecay2, i64 80, i64 0, i64 80, i64 10, i64 0, i64 2), "QUAL.OSS.DEP.IN"([10 x i32*]* %arraydecay3, i64 80, i64 0, i64 80, i64 10, i64 3, i64 7) ] 
+
+// CHECK: %4 = call token @llvm.directive.region.entry() [ "DIR.OSS"([5 x i8] c"TASK\00"), "QUAL.OSS.SHARED"([10 x [10 x i32*]]* %aFix), "QUAL.OSS.DEP.IN"([10 x i32*]* %arraydecay4, i64 80, i64 0, i64 80, i64 10, i64 5, i64 6), "QUAL.OSS.DEP.IN"([10 x i32*]* %arraydecay5, i64 80, i64 8, i64 80, i64 10, i64 5, i64 6), "QUAL.OSS.DEP.IN"([10 x i32*]* %arraydecay6, i64 80, i64 0, i64 16, i64 10, i64 5, i64 6), "QUAL.OSS.DEP.IN"([10 x i32*]* %arraydecay7, i64 80, i64 24, i64 56, i64 10, i64 5, i64 6) ] 
+// CHECK-NEXT: %5 = call token @llvm.directive.region.entry() [ "DIR.OSS"([5 x i8] c"TASK\00"), "QUAL.OSS.SHARED.VLA"([7 x i32]* %vla, i64 %1, i64 7), "QUAL.OSS.DEP.IN"([7 x i32]* %vla, i64 28, i64 0, i64 28, i64 %1, i64 0, i64 %1), "QUAL.OSS.DEP.IN"([7 x i32]* %vla, i64 28, i64 0, i64 28, i64 %1, i64 1, i64 %1), "QUAL.OSS.DEP.IN"([7 x i32]* %vla, i64 28, i64 0, i64 28, i64 %1, i64 0, i64 2), "QUAL.OSS.DEP.IN"([7 x i32]* %vla, i64 28, i64 0, i64 28, i64 %1, i64 3, i64 7) ] 
+// CHECK-NEXT: %6 = call token @llvm.directive.region.entry() [ "DIR.OSS"([5 x i8] c"TASK\00"), "QUAL.OSS.SHARED.VLA"([7 x i32]* %vla, i64 %1, i64 7), "QUAL.OSS.DEP.IN"([7 x i32]* %vla, i64 28, i64 0, i64 28, i64 %1, i64 5, i64 6), "QUAL.OSS.DEP.IN"([7 x i32]* %vla, i64 28, i64 4, i64 28, i64 %1, i64 5, i64 6), "QUAL.OSS.DEP.IN"([7 x i32]* %vla, i64 28, i64 0, i64 8, i64 %1, i64 5, i64 6), "QUAL.OSS.DEP.IN"([7 x i32]* %vla, i64 28, i64 12, i64 28, i64 %1, i64 5, i64 6) ] 
+