Duplicate UnreachableBlock, ExceptionSlot and EHSelectorSlor for each task

Author: mikaoP

clang/lib/CodeGen/CGException.cpp

@@ -402,12 +402,34 @@ void CodeGenFunction::EmitAnyExprToExn(const Expr *e, Address addr) {
 }
 
 Address CodeGenFunction::getExceptionSlot() {
+  if (getContext().getLangOpts().OmpSs
+      && CGM.getOmpSsRuntime().inTaskBody()) {
+    Address ESlotAddr = CGM.getOmpSsRuntime().getTaskExceptionSlot();
+    if (ESlotAddr.isValid())
+      return ESlotAddr;
+    llvm::Instruction *I = CreateTempAlloca(Int8PtrTy, "exn.slot");
+    Address Addr = Address(I, getPointerAlign());
+    CGM.getOmpSsRuntime().setTaskExceptionSlot(Addr);
+    return Addr;
+  }
+
   if (!ExceptionSlot)
     ExceptionSlot = CreateTempAlloca(Int8PtrTy, "exn.slot");
   return Address(ExceptionSlot, getPointerAlign());
 }
 
 Address CodeGenFunction::getEHSelectorSlot() {
+  if (getContext().getLangOpts().OmpSs
+      && CGM.getOmpSsRuntime().inTaskBody()) {
+    Address EHSSlotAddr = CGM.getOmpSsRuntime().getTaskEHSelectorSlot();
+    if (EHSSlotAddr.isValid())
+      return EHSSlotAddr;
+    llvm::Instruction *I = CreateTempAlloca(Int32Ty, "ehselector.slot");
+    Address Addr = Address(I, CharUnits::fromQuantity(4));
+    CGM.getOmpSsRuntime().setTaskEHSelectorSlot(Addr);
+    return Addr;
+  }
+
   if (!EHSelectorSlot)
     EHSelectorSlot = CreateTempAlloca(Int32Ty, "ehselector.slot");
   return Address(EHSelectorSlot, CharUnits::fromQuantity(4));

clang/lib/CodeGen/CGOmpSsRuntime.cpp

@@ -907,6 +907,17 @@ llvm::BasicBlock *CGOmpSsRuntime::getTaskTerminateLandingPad() {
   return TaskStack.back().TerminateLandingPad;
 }
 
+llvm::BasicBlock *CGOmpSsRuntime::getTaskUnreachableBlock() {
+  return TaskStack.back().UnreachableBlock;
+}
+
+Address CGOmpSsRuntime::getTaskExceptionSlot() {
+  return TaskStack.back().ExceptionSlot;
+}
+Address CGOmpSsRuntime::getTaskEHSelectorSlot() {
+  return TaskStack.back().EHSelectorSlot;
+}
+
 void CGOmpSsRuntime::setTaskTerminateHandler(llvm::BasicBlock *BB) {
   TaskStack.back().TerminateHandler = BB;
 }
@@ -915,6 +926,17 @@ void CGOmpSsRuntime::setTaskTerminateLandingPad(llvm::BasicBlock *BB) {
   TaskStack.back().TerminateLandingPad = BB;
 }
 
+void CGOmpSsRuntime::setTaskUnreachableBlock(llvm::BasicBlock *BB) {
+  TaskStack.back().UnreachableBlock = BB;
+}
+
+void CGOmpSsRuntime::setTaskExceptionSlot(Address Addr) {
+  TaskStack.back().ExceptionSlot = Addr;
+}
+void CGOmpSsRuntime::setTaskEHSelectorSlot(Address Addr) {
+  TaskStack.back().EHSelectorSlot = Addr;
+}
+
 // Borrowed brom CodeGenFunction.cpp
 static void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) {
   if (!BB) return;
@@ -1000,7 +1022,10 @@ void CGOmpSsRuntime::emitTaskCall(CodeGenFunction &CGF,
   llvm::Instruction *TaskAllocaInsertPt = new llvm::BitCastInst(Undef, CGF.Int32Ty, "taskallocapt", Result->getParent());
   TaskStack.push_back({TaskAllocaInsertPt,
                        /*TerminateLandingPad=*/nullptr,
-                       /*TerminateHandler=*/nullptr});
+                       /*TerminateHandler=*/nullptr,
+                       /*UnreachableBlock=*/nullptr,
+                       /*ExceptionSlot=*/Address::invalid(),
+                       /*EHSelectorSlot=*/Address::invalid()});
 
   // The point of exit cannot be a branch out of the structured block.
   // longjmp() and throw() must not violate the entry/exit criteria.
@@ -1015,8 +1040,7 @@ void CGOmpSsRuntime::emitTaskCall(CodeGenFunction &CGF,
   // EmitIfUsed(*this, EHResumeBlock);
   EmitIfUsed(CGF, TaskStack.back().TerminateLandingPad);
   EmitIfUsed(CGF, TaskStack.back().TerminateHandler);
-  // TODO: do we need this?
-  // EmitIfUsed(*this, UnreachableBlock);
+  EmitIfUsed(CGF, TaskStack.back().UnreachableBlock);
 
   CGF.Builder.CreateCall(ExitCallee, Result);
 

clang/lib/CodeGen/CGOmpSsRuntime.h

@@ -81,8 +81,11 @@ class CGOmpSsRuntime {
 private:
   struct TaskContext {
     llvm::AssertingVH<llvm::Instruction> InsertPt;
-    llvm::BasicBlock *TerminateLandingPad = nullptr;
-    llvm::BasicBlock *TerminateHandler = nullptr;
+    llvm::BasicBlock *TerminateLandingPad;
+    llvm::BasicBlock *TerminateHandler;
+    llvm::BasicBlock *UnreachableBlock;
+    Address ExceptionSlot;
+    Address EHSelectorSlot;
   };
 
   SmallVector<TaskContext, 2> TaskStack;
@@ -107,14 +110,27 @@ class CGOmpSsRuntime {
   bool inTaskBody();
   // returns the innermost nested task InsertPt instruction
   llvm::AssertingVH<llvm::Instruction> getTaskInsertPt();
-  // returns the innermost nested task TerminateHandler instruction
+  // returns the innermost nested task TerminateHandler BB
   llvm::BasicBlock *getTaskTerminateHandler();
-  // returns the innermost nested task TerminateLandingPad instruction
+  // returns the innermost nested task TerminateLandingPad BB
   llvm::BasicBlock *getTaskTerminateLandingPad();
+  // returns the innermost nested task UnreachableBlock BB
+  llvm::BasicBlock *getTaskUnreachableBlock();
+  // returns the innermost nested task ExceptionSlot instruction
+  Address getTaskExceptionSlot();
+  // returns the innermost nested task ExceptionSlot instruction
+  Address getTaskEHSelectorSlot();
+
   // sets the innermost nested task TerminateHandler instruction
   void setTaskTerminateHandler(llvm::BasicBlock *BB);
   // sets the innermost nested task TerminateLandingPad instruction
   void setTaskTerminateLandingPad(llvm::BasicBlock *BB);
+  // sets the innermost nested task UnreachableBlock instruction
+  void setTaskUnreachableBlock(llvm::BasicBlock *BB);
+  // sets the innermost nested task ExceptionSlot address
+  void setTaskExceptionSlot(Address Addr);
+  // sets the innermost nested task EHSelectorSlot address
+  void setTaskEHSelectorSlot(Address Addr);
 
   /// Emit code for 'taskwait' directive.
   virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc);

clang/lib/CodeGen/CodeGenFunction.h

@@ -16,6 +16,7 @@
 #include "CGBuilder.h"
 #include "CGDebugInfo.h"
 #include "CGLoopInfo.h"
+#include "CGOmpSsRuntime.h"
 #include "CGValue.h"
 #include "CodeGenModule.h"
 #include "CodeGenPGO.h"
@@ -1770,6 +1771,19 @@ class CodeGenFunction : public CodeGenTypeCache {
   Address getNormalCleanupDestSlot();
 
   llvm::BasicBlock *getUnreachableBlock() {
+    if (getContext().getLangOpts().OmpSs
+        && CGM.getOmpSsRuntime().inTaskBody()) {
+          llvm::BasicBlock *UBlock = CGM.getOmpSsRuntime().getTaskUnreachableBlock();
+          if (UBlock)
+            return UBlock;
+
+          UBlock = createBasicBlock("unreachable");
+          new llvm::UnreachableInst(getLLVMContext(), UBlock);
+
+          CGM.getOmpSsRuntime().setTaskUnreachableBlock(UBlock);
+          return UBlock;
+
+    }
     if (!UnreachableBlock) {
       UnreachableBlock = createBasicBlock("unreachable");
       new llvm::UnreachableInst(getLLVMContext(), UnreachableBlock);