First Impl. Support for Non-PODs.

OmpSsRegionAnalysis:
  - Added 'non-pod_dsa_missing' flag to detect non-pod info (i.e OSS.INIT) without DSA

OmpSsTransform:
  - Build a map<Value *, int> to map DSA with task_args position instead of computing it in everywhere
  - VLAs will be stored from largest alignment to smallest. First VLA will be aligned
    to 16 (hardcoded) at the end of task_args
  - Private VLAs will be stored in task_args.
  - Dtor call is added just before 'ret' instr. We assume there will be only one.

Closes llvm#9, closes llvm#37, closes llvm#35

Author: mikaoP

clang/include/clang/AST/OmpSsClause.h

@@ -370,6 +370,20 @@ class OSSPrivateClause final
                                           SourceLocation(), SourceLocation(),
                                           N) {}
 
+  /// Sets the list of references to private copies with initializers for
+  /// new private variables.
+  /// \param VL List of references.
+  void setPrivateCopies(ArrayRef<Expr *> VL);
+
+  /// Gets the list of references to private copies with initializers for
+  /// new private variables.
+  MutableArrayRef<Expr *> getPrivateCopies() {
+    return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
+  }
+  ArrayRef<const Expr *> getPrivateCopies() const {
+    return llvm::makeArrayRef(varlist_end(), varlist_size());
+  }
+
 public:
   /// Creates clause with a list of variables \a VL.
   ///
@@ -378,16 +392,33 @@ class OSSPrivateClause final
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   /// \param VL List of references to the variables.
+  /// \param PrivateVL List of references to private copies with initializers.
   static OSSPrivateClause *Create(const ASTContext &C, SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
-                                 SourceLocation EndLoc, ArrayRef<Expr *> VL);
+                                 SourceLocation EndLoc,
+                                 ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL);
 
   /// Creates an empty clause with \a N variables.
   ///
   /// \param C AST context.
   /// \param N The number of variables.
   static OSSPrivateClause *CreateEmpty(const ASTContext &C, unsigned N);
 
+  using private_copies_iterator = MutableArrayRef<Expr *>::iterator;
+  using private_copies_const_iterator = ArrayRef<const Expr *>::iterator;
+  using private_copies_range = llvm::iterator_range<private_copies_iterator>;
+  using private_copies_const_range =
+      llvm::iterator_range<private_copies_const_iterator>;
+
+  private_copies_range private_copies() {
+    return private_copies_range(getPrivateCopies().begin(),
+                                getPrivateCopies().end());
+  }
+  private_copies_const_range private_copies() const {
+    return private_copies_const_range(getPrivateCopies().begin(),
+                                      getPrivateCopies().end());
+  }
+
   child_range children() {
     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
                        reinterpret_cast<Stmt **>(varlist_end()));
@@ -431,6 +462,34 @@ class OSSFirstprivateClause final
                                           SourceLocation(), SourceLocation(),
                                           N) {}
 
+  /// Sets the list of references to private copies with initializers for
+  /// new private variables.
+  /// \param VL List of references.
+  void setPrivateCopies(ArrayRef<Expr *> VL);
+
+  /// Gets the list of references to private copies with initializers for
+  /// new private variables.
+  MutableArrayRef<Expr *> getPrivateCopies() {
+    return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
+  }
+  ArrayRef<const Expr *> getPrivateCopies() const {
+    return llvm::makeArrayRef(varlist_end(), varlist_size());
+  }
+
+  /// Sets the list of references to initializer variables for new
+  /// private variables.
+  /// \param VL List of references.
+  void setInits(ArrayRef<Expr *> VL);
+
+  /// Gets the list of references to initializer variables for new
+  /// private variables.
+  MutableArrayRef<Expr *> getInits() {
+    return MutableArrayRef<Expr *>(getPrivateCopies().end(), varlist_size());
+  }
+  ArrayRef<const Expr *> getInits() const {
+    return llvm::makeArrayRef(getPrivateCopies().end(), varlist_size());
+  }
+
 public:
   /// Creates clause with a list of variables \a VL.
   ///
@@ -439,16 +498,47 @@ class OSSFirstprivateClause final
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   /// \param VL List of references to the variables.
-  static OSSFirstprivateClause *Create(const ASTContext &C, SourceLocation StartLoc,
-                                 SourceLocation LParenLoc,
-                                 SourceLocation EndLoc, ArrayRef<Expr *> VL);
+  /// \param PrivateVL List of references to private copies with initializers.
+  /// \param InitVL List of references to auto generated variables used for
+  /// initialization.
+  static OSSFirstprivateClause *
+  Create(const ASTContext &C, SourceLocation StartLoc,
+         SourceLocation LParenLoc, SourceLocation EndLoc,
+         ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL, ArrayRef<Expr *> InitVL);
 
   /// Creates an empty clause with \a N variables.
   ///
   /// \param C AST context.
   /// \param N The number of variables.
   static OSSFirstprivateClause *CreateEmpty(const ASTContext &C, unsigned N);
 
+  using private_copies_iterator = MutableArrayRef<Expr *>::iterator;
+  using private_copies_const_iterator = ArrayRef<const Expr *>::iterator;
+  using private_copies_range = llvm::iterator_range<private_copies_iterator>;
+  using private_copies_const_range =
+      llvm::iterator_range<private_copies_const_iterator>;
+
+  private_copies_range private_copies() {
+    return private_copies_range(getPrivateCopies().begin(),
+                                getPrivateCopies().end());
+  }
+  private_copies_const_range private_copies() const {
+    return private_copies_const_range(getPrivateCopies().begin(),
+                                      getPrivateCopies().end());
+  }
+
+  using inits_iterator = MutableArrayRef<Expr *>::iterator;
+  using inits_const_iterator = ArrayRef<const Expr *>::iterator;
+  using inits_range = llvm::iterator_range<inits_iterator>;
+  using inits_const_range = llvm::iterator_range<inits_const_iterator>;
+
+  inits_range inits() {
+    return inits_range(getInits().begin(), getInits().end());
+  }
+  inits_const_range inits() const {
+    return inits_const_range(getInits().begin(), getInits().end());
+  }
+
   child_range children() {
     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
                        reinterpret_cast<Stmt **>(varlist_end()));

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -9889,8 +9889,6 @@ def err_oss_expected_addressable_lvalue_or_array_item : Error<
   "expected addressable lvalue expression, array element or array section">;
 def err_oss_expected_var_name_member_expr : Error<
   "expected variable name%select{| or data member of current class}0">;
-def err_oss_non_pod_not_supported: Error<
-  "Non-POD structs are not supported">;
 
 def err_oss_not_integral : Error<
   "expression must have integral or unscoped enumeration "

clang/lib/AST/OmpSsClause.cpp

@@ -35,15 +35,24 @@ OSSClause::child_range OSSClause::children() {
   llvm_unreachable("unknown OSSClause");
 }
 
+void OSSPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
+  assert(VL.size() == varlist_size() &&
+         "Number of private copies is not the same as the preallocated buffer");
+  std::copy(VL.begin(), VL.end(), varlist_end());
+}
+
 OSSPrivateClause *OSSPrivateClause::Create(const ASTContext &C,
                                          SourceLocation StartLoc,
                                          SourceLocation LParenLoc,
                                          SourceLocation EndLoc,
-                                         ArrayRef<Expr *> VL) {
-  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
+                                         ArrayRef<Expr *> VL,
+                                         ArrayRef<Expr *> PrivateVL) {
+  // Info of item 'i' is in VL[i], PrivateVL[i]
+  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * VL.size()));
   OSSPrivateClause *Clause =
       new (Mem) OSSPrivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
   Clause->setVarRefs(VL);
+  Clause->setPrivateCopies(PrivateVL);
   return Clause;
 }
 
@@ -52,15 +61,32 @@ OSSPrivateClause *OSSPrivateClause::CreateEmpty(const ASTContext &C, unsigned N)
   return new (Mem) OSSPrivateClause(N);
 }
 
+void OSSFirstprivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
+  assert(VL.size() == varlist_size() &&
+         "Number of private copies is not the same as the preallocated buffer");
+  std::copy(VL.begin(), VL.end(), varlist_end());
+}
+
+void OSSFirstprivateClause::setInits(ArrayRef<Expr *> VL) {
+  assert(VL.size() == varlist_size() &&
+         "Number of inits is not the same as the preallocated buffer");
+  std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
+}
+
 OSSFirstprivateClause *OSSFirstprivateClause::Create(const ASTContext &C,
                                          SourceLocation StartLoc,
                                          SourceLocation LParenLoc,
                                          SourceLocation EndLoc,
-                                         ArrayRef<Expr *> VL) {
-  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
+                                         ArrayRef<Expr *> VL,
+                                         ArrayRef<Expr *> PrivateVL,
+                                         ArrayRef<Expr *> InitVL) {
+  // Info of item 'i' is in VL[i], PrivateVL[i] and InitVL[i]
+  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * VL.size()));
   OSSFirstprivateClause *Clause =
       new (Mem) OSSFirstprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
   Clause->setVarRefs(VL);
+  Clause->setPrivateCopies(PrivateVL);
+  Clause->setInits(InitVL);
   return Clause;
 }
 

clang/lib/CodeGen/CGExpr.cpp

@@ -110,7 +110,7 @@ llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(llvm::Type *Ty,
                                                     llvm::Value *ArraySize) {
   if (ArraySize)
     return Builder.CreateAlloca(Ty, ArraySize, Name);
-  if (getLangOpts().OmpSs && CGM.getOmpSsRuntime().inTask())
+  if (getLangOpts().OmpSs && CGM.getOmpSsRuntime().inTask() && !CGM.getOmpSsRuntime().ForceSkip)
     return new llvm::AllocaInst(Ty, CGM.getDataLayout().getAllocaAddrSpace(),
                                 ArraySize, Name,
                                 CGM.getOmpSsRuntime().getCurrentTask());