CodeGen: Place OmpSs-2 task's allocas at the beginning of the task instead of the beginning of the function

Closes llvm#32

Author: mikaoP

clang/lib/CodeGen/CGExpr.cpp

@@ -17,6 +17,7 @@
 #include "CGDebugInfo.h"
 #include "CGObjCRuntime.h"
 #include "CGOpenMPRuntime.h"
+#include "CGOmpSsRuntime.h"
 #include "CGRecordLayout.h"
 #include "CodeGenFunction.h"
 #include "CodeGenModule.h"
@@ -108,6 +109,11 @@ llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(llvm::Type *Ty,
                                                     llvm::Value *ArraySize) {
   if (ArraySize)
     return Builder.CreateAlloca(Ty, ArraySize, Name);
+  if (getLangOpts().OmpSs && CGM.getOmpSsRuntime().inTask())
+    return new llvm::AllocaInst(Ty, CGM.getDataLayout().getAllocaAddrSpace(),
+                                ArraySize, Name,
+                                CGM.getOmpSsRuntime().getCurrentTask());
+
   return new llvm::AllocaInst(Ty, CGM.getDataLayout().getAllocaAddrSpace(),
                               ArraySize, Name, AllocaInsertPt);
 }

clang/lib/CodeGen/CGOmpSsRuntime.cpp

@@ -350,6 +350,14 @@ void CGOmpSsRuntime::emitTaskwaitCall(CodeGenFunction &CGF,
                                                                                     "TASKWAIT"))});
 }
 
+bool CGOmpSsRuntime::inTask() {
+  return !TaskEntryStack.empty();
+}
+
+llvm::AssertingVH<llvm::Instruction> CGOmpSsRuntime::getCurrentTask() {
+  return TaskEntryStack.back();
+}
+
 void CGOmpSsRuntime::emitTaskCall(CodeGenFunction &CGF,
                                   const OSSExecutableDirective &D,
                                   SourceLocation Loc,
@@ -386,14 +394,21 @@ void CGOmpSsRuntime::emitTaskCall(CodeGenFunction &CGF,
     EmitDependency("QUAL.OSS.DEP.WEAKINOUT", CGF, E, TaskInfo);
   }
 
-  llvm::Value *Result =
-    CGF.Builder.CreateCall(EntryCallee,
-                           {},
-                           llvm::makeArrayRef(TaskInfo));
+  llvm::Instruction *Result =
+    CGF.Builder.CreateCall(EntryCallee, {}, llvm::makeArrayRef(TaskInfo));
+
+  // Push Task Stack
+  llvm::Value *Undef = llvm::UndefValue::get(CGF.Int32Ty);
+  llvm::Instruction *TaskAllocaInsertPt = new llvm::BitCastInst(Undef, CGF.Int32Ty, "taskallocapt", Result->getParent());
+  TaskEntryStack.push_back(TaskAllocaInsertPt);
 
   CGF.EmitStmt(D.getAssociatedStmt());
 
-  CGF.Builder.CreateCall(ExitCallee,
-                         Result);
+  CGF.Builder.CreateCall(ExitCallee, Result);
+
+  // Pop Task Stack
+  TaskEntryStack.pop_back();
+  TaskAllocaInsertPt->eraseFromParent();
+
 }
 

clang/lib/CodeGen/CGOmpSsRuntime.h

@@ -48,13 +48,22 @@ class CGOmpSsRuntime {
 protected:
   CodeGenModule &CGM;
 
+private:
+  SmallVector<llvm::AssertingVH<llvm::Instruction>, 2> TaskEntryStack;
+
 public:
   explicit CGOmpSsRuntime(CodeGenModule &CGM) : CGM(CGM) {}
   virtual ~CGOmpSsRuntime() {};
   virtual void clear() {};
 
+  // returns true if we're emitting code inside a task context (entry/exit)
+  bool inTask();
+  // returns the innermost nested task entry mark instruction
+  llvm::AssertingVH<llvm::Instruction> getCurrentTask();
+
   /// Emit code for 'taskwait' directive.
   virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc);
+  /// Emit code for 'task' directive.
   virtual void emitTaskCall(CodeGenFunction &CGF,
                             const OSSExecutableDirective &D,
                             SourceLocation Loc,

clang/test/OmpSs/IR/task_inside_task_alloca.c

@@ -0,0 +1,70 @@
+// RUN: %clang_cc1 -verify -fompss-2 -ferror-limit 100 %s -S -emit-llvm -o - | FileCheck %s
+// expected-no-diagnostics
+
+void foo(int x) {
+  int a, b, c;
+  int va[x];
+  #pragma oss task firstprivate(x)
+  {
+      int d, e, f;
+      int va1[x];
+      #pragma oss task
+      {
+          int g, h, i;
+      }
+  }
+  #pragma oss task
+  {
+      int j, k, l;
+  }
+  int m;
+}
+
+// CHECK:        %x.addr = alloca i32, align 4
+// CHECK-NEXT:   %a = alloca i32, align 4
+// CHECK-NEXT:   %b = alloca i32, align 4
+// CHECK-NEXT:   %c = alloca i32, align 4
+// CHECK-NEXT:   %saved_stack = alloca i8*, align 8
+// CHECK-NEXT:   %__vla_expr0 = alloca i64, align 8
+// CHECK-NEXT:   %m = alloca i32, align 4
+// 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 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.FIRSTPRIVATE"(i32* %x.addr) ]
+// CHECK-NEXT:     %d = alloca i32, align 4
+// CHECK-NEXT:     %e = alloca i32, align 4
+// CHECK-NEXT:     %f = alloca i32, align 4
+// CHECK-NEXT:     %saved_stack1 = alloca i8*, align 8
+// CHECK-NEXT:     %__vla_expr1 = alloca i64, align 8
+// CHECK-NEXT:     %4 = load i32, i32* %x.addr, align 4
+// CHECK-NEXT:     %5 = zext i32 %4 to i64
+// CHECK-NEXT:     %6 = call i8* @llvm.stacksave()
+// CHECK-NEXT:     store i8* %6, i8** %saved_stack1, align 8
+// CHECK-NEXT:     %vla2 = alloca i32, i64 %5, align 16
+// CHECK-NEXT:     store i64 %5, i64* %__vla_expr1, align 8
+
+// CHECK:          %7 = call token @llvm.directive.region.entry() [ "DIR.OSS"([5 x i8] c"TASK\00") ]
+// CHECK-NEXT:       %g = alloca i32, align 4
+// CHECK-NEXT:       %h = alloca i32, align 4
+// CHECK-NEXT:       %i = alloca i32, align 4
+// CHECK-NEXT:     call void @llvm.directive.region.exit(token %7)
+
+// CHECK:        %8 = load i8*, i8** %saved_stack1, align 8
+// CHECK-NEXT:   call void @llvm.stackrestore(i8* %8)
+
+// CHECK:        call void @llvm.directive.region.exit(token %3)
+
+// CHECK:        %9 = call token @llvm.directive.region.entry() [ "DIR.OSS"([5 x i8] c"TASK\00") ]
+// CHECK-NEXT:     %j = alloca i32, align 4
+// CHECK-NEXT:     %k = alloca i32, align 4
+// CHECK-NEXT:     %l = alloca i32, align 4
+// CHECK-NEXT:   call void @llvm.directive.region.exit(token %9)
+
+// CHECK:        %10 = load i8*, i8** %saved_stack, align 8
+// CHECK-NEXT:   call void @llvm.stackrestore(i8* %10)
+