[OPENMP] Initial codegen for 'omp task' directive.

[ABataev]

Summary

The task region is emmitted in several steps:

1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32 gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds, kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the function:

kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
  TaskFunction(gtid, tt->part_id, tt->shareds);
  return 0;
}

2. Copy a list of shared variables to field shareds of the resulting structure kmp_task_t returned by the previous call (if any).
3. Copy a pointer to destructions function to field destructions of the resulting structure kmp_task_t.
4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid, kmp_task_t *new_task), where new_task is a resulting structure from previous items.

[ABataev]

Ping!

[ABataev]

Ping!

[rjmccall]

Sorry for the delay.

In general, your code is very difficult to read; it doesn't use any vertical whitespace within functions at all, so I can't easily understand how things are supposed to be grouped.

The basic implementation seems fine, though I have a number of requests:

lib/CodeGen/CGOpenMPRuntime.cpp

118

Build this type lazily, please.

119

A better way of commenting the next few lines would be to just write the struct definition out and then put all the addFieldToRecordDecl calls together.

133

Build this type lazily, please.

252

It looks like the invariants about getThreadIDVariable have changed; it used to always be an int32*, and now it can be either that or an int32. EmitThreadIDAddress appears to still assume that it's an ident*. You should fix that and then add a test that the OpenMP constructs using that still work correctly within a task.

You should also document this on CGOpenMPRegionInfo::ThreadIDVar.

257

Missing braces.

1009

Somewhere around here would be a good place to put the code that lazily builds KmpTaskTRD.

1012

Comment, please. Please include the fact that this leaves the RecordDecl incomplete.

Also, RD has to be KmpTaskTRD, so remove that argument and make this take the CGOpenMPRuntime.

1093

Please add a newline after this comment to make it clear that it's describing the next sequence of steps as a whole.

lib/CodeGen/CGOpenMPRuntime.h

17

I don't think you need this; you can just forward-declare QualType. If you do need this, you can remove the forward-declaration of RecordDecl, I am positive that Type.h does that already.

288

I was concerned about awkwardly making a single function do completely different things based on weird defaulted parameter, but it turns out that those types are exactly the same.

Would it be more appropriate to say that this creates an outlined function, and that if PartID is given, it's bound to the appropriate parameter value?

Although it also looks like PartIDVar is completely ignored except for an assertion. Is that expected to change?

lib/Sema/SemaOpenMP.cpp

1124

This seems be hard-coding KMP runtime assumptions into Sema and the AST. Is that unavoidable?

[ABataev]

John, thanks for the review!

lib/CodeGen/CGOpenMPRuntime.cpp

118

Ok

119

Ok

133

Ok

252

I'll fix it.

257

My bad, will be fixed

1012

Ok, I'll improve it

1093

Ok, will be done.

lib/CodeGen/CGOpenMPRuntime.h

17

I'll fix it.

288

I'll try to split this function in two - one for tasks and another one for parallel regions. I think this is better, rather than keep too complex single function.

lib/Sema/SemaOpenMP.cpp

1124

Unfortunately, no. I'm trying to avoid runtime assumptions in common code, but sometimes (like function parameters for outlined functions) I'm just forced to make some hard-coding of runtime specific features.

[ABataev]

Update after review

[rjmccall]

Sorry for the delay. Phabricator's been acting up; you'll notice a couple of comments that I wasn't able to delete, because deleting them locked the webpage up and never applied the deletion. Hooray for tools.

Generally looking better.

lib/CodeGen/CGOpenMPRuntime.cpp

45

Okay. I think I see what you've done here with the subclass, so that this always produces a ident_t l-value, and thus its address is always an ident_t*. That makes a lot of sense to me. Please document that.

73

.

73

.

77

.

152

This is a great assertion, thanks.

983

*Indexes* of fields in type kmp_task_t.

1045

Closing parenthesis. Also, I'd make a getter for this instead of inlining it here.

1075

Argument comments are useful when somebody reading the code might not understand the purpose of the argument. In this case, that purpose is pretty obvious from the argument expression itself, so the comment is useless.

1111

It's generally better to emit helper functions in a separate function, so that any particular function only knows about one CodeGenFunction object:

• It removes some code from what's already a pretty large function.
• It makes the shared data between the two functions a lot more obvious.
• It removes any confusion about which function any particular llvm::Value* is valid in, so that you aren't tempted to (e.g.) use SharedsParam in the CGF function instead of the TaskEntryCGF function.

1147

You're probably going to need to ask Sema to generate a copy constructor expression to get this right in C++. Feel free to do that in a separate patch.

1163

Nothing cares about the result of this call?

lib/CodeGen/CGOpenMPRuntime.h

288

I'd write these as parameter names, i.e. void (*)(kmp_int32 *ThreadID, kip_int32 BoundID, struct context_vars*). The C-style comment right next to the * is really hard to read.

299

Same thing. Just write these comments as parameter names.

lib/CodeGen/CGStmtOpenMP.cpp

762

You don't need to comment obvious arguments like this (and like a few other places nearby). The reader understands what the purpose of the argument is, and "K=" doesn't add anything meaningful anyway.

771

Braces.

[ABataev]

John, thanks for the review!

lib/CodeGen/CGOpenMPRuntime.cpp

45

Ok, will do

983

Ok, thanks.

1045

Ok, agree, that getter would look much better.

1075

Ok, removed

1111

Agree, I will create a separate function for proxy function

1147

I don't think I need to call a copy constructor here. Actually structure with a list of shared variables is always POD type (it stores only pointers and integer values), so we can simply copy it

1163

The check is required for untied tasks only, but they are not supported yet. I'll add TODO here.

lib/CodeGen/CGOpenMPRuntime.h

288

Fixed

299

Fixed

lib/CodeGen/CGStmtOpenMP.cpp

762

Ok, removed

771

Fixed

[ABataev]

Update after review

[rjmccall]

Okay, if all the shareds are by-reference or something, that certainly simplifies things.

LGTM, thanks!

lib/CodeGen/CGOpenMPRuntime.h

 //===----- CGOpenMPRuntime.h - Interface to OpenMP Runtimes -----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This provides a class for OpenMP runtime code generation.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
 #define LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
 
+#include "clang/AST/Type.h"
 #include "clang/Basic/OpenMPKinds.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/IR/ValueHandle.h"
 
 namespace llvm {
 class ArrayType;
 class Constant;
 class Function;
 class FunctionType;
 class GlobalVariable;
 class StructType;
 class Type;
 class Value;
 } // namespace llvm
 
 namespace clang {
 class Expr;
 class OMPExecutableDirective;
+class RecordDecl;
 class VarDecl;
 
 namespace CodeGen {
 
 class CodeGenFunction;
 class CodeGenModule;
 
 class CGOpenMPRuntime {
-public:
-
 private:
   enum OpenMPRTLFunction {
     /// \brief Call to void __kmpc_fork_call(ident_t *loc, kmp_int32 argc,
     /// kmpc_micro microtask, ...);
     OMPRTL__kmpc_fork_call,
     /// \brief Call to void *__kmpc_threadprivate_cached(ident_t *loc,
     /// kmp_int32 global_tid, void *data, size_t size, void ***cache);
     OMPRTL__kmpc_threadprivate_cached,
enum OpenMPRTLFunction {
     // kmp_int32 num_threads);
     OMPRTL__kmpc_push_num_threads,
     // Call to void __kmpc_flush(ident_t *loc, ...);
     OMPRTL__kmpc_flush,
     // Call to kmp_int32 __kmpc_master(ident_t *, kmp_int32 global_tid);
     OMPRTL__kmpc_master,
     // Call to void __kmpc_end_master(ident_t *, kmp_int32 global_tid);
     OMPRTL__kmpc_end_master,
+    // Call to kmp_task_t * __kmpc_omp_task_alloc(ident_t *, kmp_int32 gtid,
+    // kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
+    // kmp_routine_entry_t *task_entry);
+    OMPRTL__kmpc_omp_task_alloc,
+    // Call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid, kmp_task_t *
+    // new_task);
+    OMPRTL__kmpc_omp_task,
   };
 
   /// \brief Values for bit flags used in the ident_t to describe the fields.
   /// All enumeric elements are named and described in accordance with the code
   /// from http://llvm.org/svn/llvm-project/openmp/trunk/runtime/src/kmp.h
   enum OpenMPLocationFlags {
     /// \brief Use trampoline for internal microtask.
     OMP_IDENT_IMD = 0x01,
private:
   llvm::ArrayType *KmpCriticalNameTy;
   /// \brief An ordered map of auto-generated variables to their unique names.
   /// It stores variables with the following names: 1) ".gomp_critical_user_" +
   /// <critical_section_name> + ".var" for "omp critical" directives; 2)
   /// <mangled_name_for_global_var> + ".cache." for cache for threadprivate
   /// variables.
   llvm::StringMap<llvm::AssertingVH<llvm::Constant>, llvm::BumpPtrAllocator>
       InternalVars;
+  /// \brief Type typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *);
+  llvm::Type *KmpRoutineEntryPtrTy;
+  /// \brief This type is used by the tasking constructs. It stores a list of
+  /// shared variables (field shareds), pointer to the outlined task function
+  /// (field routine), current partition id for untied tasks (field part_id),
+  /// pointer to the function with destructors for the private variables(field
+  /// destructors) and a list of private variables itself (if any).
+  /// \code
+  /// struct kmp_task_t {
+  ///         void *              shareds;
+  ///         kmp_routine_entry_t routine;
+  ///         kmp_int32           part_id;
+  ///         kmp_routine_entry_t destructors;
+  ///         /*  private vars  */
+  ///       };
+  /// \endcode
+  llvm::Type *KmpTaskTTy;
+  /// \brief Original RecordDecl for kmp_task_t type.
+  const RecordDecl *KmpTaskTRD;
 
   /// \brief Emits object of ident_t type with info for source location.
   /// \param Flags Flags for OpenMP location.
   ///
   llvm::Value *
   EmitOpenMPUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc,
                            OpenMPLocationFlags Flags = OMP_IDENT_KMPC);
 

 
 public:
   explicit CGOpenMPRuntime(CodeGenModule &CGM);
   virtual ~CGOpenMPRuntime() {}
 
   /// \brief Emits outlined function for the specified OpenMP directive \a D
   /// (required for parallel and task directives). This outlined function has
   /// type void(*)(kmp_int32 /*ThreadID*/, kmp_int32 /*BoundID*/, struct
-  /// context_vars*).
+  /// context_vars*) (if PartIdVar == nullptr) or void(*)(kmp_int32
+  /// /*ThreadID*/, kmp_int32 /*PartID*/, struct context_vars*) (if PartIdVar !=
+  /// nullptr).
   /// \param D OpenMP directive.
   /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
-  ///
+  /// \param PartID If not nullptr - variable used for part id in tasks.
   virtual llvm::Value *
   EmitOpenMPOutlinedFunction(const OMPExecutableDirective &D,
-                             const VarDecl *ThreadIDVar);
+                             const VarDecl *ThreadIDVar,
+                             const VarDecl *PartIDVar = nullptr);
 
   /// \brief Cleans up references to the objects in finished function.
   ///
   void FunctionFinished(CodeGenFunction &CGF);
 
   /// \brief Emits code for parallel call of the \a OutlinedFn with variables
   /// captured in a record which address is stored in \a CapturedStruct.
   /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
   /// this function is void(*)(kmp_int32, kmp_int32, struct context_vars*).
   /// \param CapturedStruct A pointer to the record with the references to
   /// variables used in \a OutlinedFn function.
   ///
public:
   EmitOMPThreadPrivateVarDefinition(const VarDecl *VD, llvm::Value *VDAddr,
                                     SourceLocation Loc, bool PerformInit,
                                     CodeGenFunction *CGF = nullptr);
 
   /// \brief Emit flush of the variables specified in 'omp flush' directive.
   /// \param Vars List of variables to flush.
   virtual void EmitOMPFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars,
                             SourceLocation Loc);
+
+  /// \brief Emit task region for the task directive. The task region is
+  /// emmitted in two steps:
+  /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32
+  /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
+  /// kmp_routine_entry_t *task_entry). Here task_entry is a pointer to the
+  /// function:
+  /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
+  ///   TaskFunction(gtid, tt->part_id, tt->shareds);
+  ///   return 0;
+  /// }
+  /// 2. Copy a list of shared variables to field shareds of the resulting
+  /// structure kmp_task_t returned by the previous call (if any).
+  /// 3. Copy a pointer to destructions function to field destructions of the
+  /// resulting structure kmp_task_t.
+  /// 4. Emit a call to kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid,
+  /// kmp_task_t *new_task), where new_task is a resulting structure from
+  /// previous items.
+  /// \param Tied true if the task is tied (the task is tied to the thread that
+  /// can suspend its task region), false - untied (the task is not tied to any
+  /// thread).
+  /// \param Final Contains either constant bool value, or llvm::Value * of i1
+  /// type for final clause. If the value is true, the task forces all of its
+  /// child tasks to become final and included tasks.
+  /// \param TaskFunction An LLVM function with type void (*)(i32 /*gtid*/, i32
+  /// /*part_id*/, captured_struct */*__context*/);
+  /// \param SharedsTy A type which contains references the shared variables.
+  /// \param Shareds Context with the list of shared variables from the \a
+  /// TaskFunction.
+  virtual void
+  EmitOMPTaskCall(CodeGenFunction &CGF, SourceLocation Loc, bool Tied,
+                  llvm::PointerIntPair<llvm::Value *, 1, bool> Final,
+                  llvm::Value *TaskFunction, QualType SharedsTy,
+                  llvm::Value *Shareds);
 };
 } // namespace CodeGen
 } // namespace clang
 
 #endif

lib/CodeGen/CGOpenMPRuntime.cpp

 using namespace clang;
 using namespace CodeGen;
 
 namespace {
 /// \brief API for captured statement code generation in OpenMP constructs.
 class CGOpenMPRegionInfo : public CodeGenFunction::CGCapturedStmtInfo {
 public:
   CGOpenMPRegionInfo(const OMPExecutableDirective &D, const CapturedStmt &CS,
-                     const VarDecl *ThreadIDVar)
+                     const VarDecl *ThreadIDVar, const VarDecl *PartIDVar)
       : CGCapturedStmtInfo(CS, CR_OpenMP), ThreadIDVar(ThreadIDVar),
-        Directive(D) {
+        PartIDVar(PartIDVar), Directive(D) {
     assert(ThreadIDVar != nullptr && "No ThreadID in OpenMP region.");
   }
 
   /// \brief Gets a variable or parameter for storing global thread id
   /// inside OpenMP construct.
   const VarDecl *getThreadIDVariable() const { return ThreadIDVar; }
 
   /// \brief Gets an LValue for the current ThreadID variable.
   LValue getThreadIDVariableLValue(CodeGenFunction &CGF);
 
   static bool classof(const CGCapturedStmtInfo *Info) {
     return Info->getKind() == CR_OpenMP;
   }
 
   /// \brief Emit the captured statement body.
   void EmitBody(CodeGenFunction &CGF, Stmt *S) override;
 
   /// \brief Get the name of the capture helper.
   StringRef getHelperName() const override { return ".omp_outlined."; }
 
 private:
   /// \brief A variable or parameter storing global thread id for OpenMP
   /// constructs.
   const VarDecl *ThreadIDVar;
+  /// \brief A variable or parameter storing part id for OpenMP tasking
+  /// constructs.
+  const VarDecl *PartIDVar;
   /// \brief OpenMP executable directive associated with the region.
   const OMPExecutableDirective &Directive;
 };
 } // namespace
 
 LValue CGOpenMPRegionInfo::getThreadIDVariableLValue(CodeGenFunction &CGF) {
   return CGF.MakeNaturalAlignAddrLValue(
       CGF.GetAddrOfLocalVar(ThreadIDVar),
       CGF.getContext().getPointerType(ThreadIDVar->getType()));
 }
 
 void CGOpenMPRegionInfo::EmitBody(CodeGenFunction &CGF, Stmt *S) {
   CodeGenFunction::OMPPrivateScope PrivateScope(CGF);
   CGF.EmitOMPPrivateClause(Directive, PrivateScope);
   CGF.EmitOMPFirstprivateClause(Directive, PrivateScope);
+  // TODO: add support for privates in tasks.
+  assert((!PartIDVar || !PrivateScope.Privatize()) &&
+         "Private clauses for tasks are not supported yet.");
   if (PrivateScope.Privatize())
     // Emit implicit barrier to synchronize threads and avoid data races.
     CGF.CGM.getOpenMPRuntime().EmitOMPBarrierCall(CGF, Directive.getLocStart(),
                                                   /*IsExplicit=*/false);
   CGCapturedStmtInfo::EmitBody(CGF, S);
 }
 
+static void addFieldToRecordDecl(ASTContext &C, DeclContext *DC,
+                                 QualType FieldTy) {
+  auto *Field = FieldDecl::Create(
+      C, DC, SourceLocation(), SourceLocation(), /*Id=*/nullptr, FieldTy,
+      C.getTrivialTypeSourceInfo(FieldTy, SourceLocation()),
+      /*BW=*/nullptr, /*Mutable=*/false, /*InitStyle=*/ICIS_NoInit);
+  Field->setAccess(AS_public);
+  DC->addDecl(Field);
+}
+
 CGOpenMPRuntime::CGOpenMPRuntime(CodeGenModule &CGM)
     : CGM(CGM), DefaultOpenMPPSource(nullptr) {
   IdentTy = llvm::StructType::create(
       "ident_t", CGM.Int32Ty /* reserved_1 */, CGM.Int32Ty /* flags */,
       CGM.Int32Ty /* reserved_2 */, CGM.Int32Ty /* reserved_3 */,
       CGM.Int8PtrTy /* psource */, nullptr);
   // Build void (*kmpc_micro)(kmp_int32 *global_tid, kmp_int32 *bound_tid,...)
   llvm::Type *MicroParams[] = {llvm::PointerType::getUnqual(CGM.Int32Ty),
                                llvm::PointerType::getUnqual(CGM.Int32Ty)};
   Kmpc_MicroTy = llvm::FunctionType::get(CGM.VoidTy, MicroParams, true);
   KmpCriticalNameTy = llvm::ArrayType::get(CGM.Int32Ty, /*NumElements*/ 8);
+  // Build typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *); type.
+  auto &C = CGM.getContext();
+  auto Int32Ty = C.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/1);
+  QualType KmpRoutineEntryTyArgs[] = {Int32Ty, C.VoidPtrTy};
+  FunctionProtoType::ExtProtoInfo EPI;
+  auto KmpRoutineEntryTy =
+      C.getFunctionType(Int32Ty, KmpRoutineEntryTyArgs, EPI);
+  auto KmpRoutineEntryPointerQTy = C.getPointerType(KmpRoutineEntryTy);
+  KmpRoutineEntryPtrTy = CGM.getTypes().ConvertType(KmpRoutineEntryPointerQTy);
+  // Build struct kmp_task_t.
+  auto *RD = C.buildImplicitRecord("kmp_task_t");
+  RD->startDefinition();
+  // Build void *shareds;
+  addFieldToRecordDecl(C, RD, C.VoidPtrTy);
+  // Build kmp_routine_entry_t routine;
+  addFieldToRecordDecl(C, RD, KmpRoutineEntryPointerQTy);
+  // Build kmp_int32 part_id;
+  addFieldToRecordDecl(C, RD, Int32Ty);
+  // Build kmp_routine_entry_t destructors;
+  addFieldToRecordDecl(C, RD, KmpRoutineEntryPointerQTy);
+  RD->completeDefinition();
+  KmpTaskTRD = RD;
+  auto KmpTaskQTy = C.getRecordType(KmpTaskTRD);
+  KmpTaskTTy = CGM.getTypes().ConvertType(KmpTaskQTy);
 }
 
 llvm::Value *
 CGOpenMPRuntime::EmitOpenMPOutlinedFunction(const OMPExecutableDirective &D,
-                                            const VarDecl *ThreadIDVar) {
+                                            const VarDecl *ThreadIDVar,
+                                            const VarDecl *PartIDVar) {
   const CapturedStmt *CS = cast<CapturedStmt>(D.getAssociatedStmt());
   CodeGenFunction CGF(CGM, true);
-  CGOpenMPRegionInfo CGInfo(D, *CS, ThreadIDVar);
+  CGOpenMPRegionInfo CGInfo(D, *CS, ThreadIDVar, PartIDVar);
   CGF.CapturedStmtInfo = &CGInfo;
   return CGF.GenerateCapturedStmtFunction(*CS);
 }
 
 llvm::Value *
 CGOpenMPRuntime::GetOrCreateDefaultOpenMPLocation(OpenMPLocationFlags Flags) {
   llvm::Value *Entry = OpenMPDefaultLocMap.lookup(Flags);
   if (!Entry) {
     if (!DefaultOpenMPPSource) {
       // Initialize default location for psource field of ident_t structure of
       // all ident_t objects. Format is ";file;function;line;column;;".
       // Taken from
       // http://llvm.org/svn/llvm-project/openmp/trunk/runtime/src/kmp_str.c
       DefaultOpenMPPSource =
           CGM.GetAddrOfConstantCString(";unknown;unknown;0;0;;");
       DefaultOpenMPPSource =
           llvm::ConstantExpr::getBitCast(DefaultOpenMPPSource, CGM.Int8PtrTy);
     }
if (ThreadID != nullptr)
       return ThreadID;
   }
   if (auto OMPRegionInfo =
           dyn_cast_or_null<CGOpenMPRegionInfo>(CGF.CapturedStmtInfo)) {
     // Check if this an outlined function with thread id passed as argument.
     auto ThreadIDVar = OMPRegionInfo->getThreadIDVariable();
     auto LVal = OMPRegionInfo->getThreadIDVariableLValue(CGF);
     auto RVal = CGF.EmitLoadOfLValue(LVal, Loc);
+    if (ThreadIDVar->getType()->isPointerType()) {
+      // Thread id is passed as a pointer
       LVal = CGF.MakeNaturalAlignAddrLValue(RVal.getScalarVal(),
                                             ThreadIDVar->getType());
       ThreadID = CGF.EmitLoadOfLValue(LVal, Loc).getScalarVal();
+    } else
+      // Thread id is passed as a value (in tasks).
+      ThreadID = RVal.getScalarVal();
     // If value loaded in entry block, cache it and use it everywhere in
     // function.
     if (CGF.Builder.GetInsertBlock() == CGF.AllocaInsertPt->getParent()) {
       auto &Elem = OpenMPLocThreadIDMap.FindAndConstruct(CGF.CurFn);
       Elem.second.ThreadID = ThreadID;
     }
   } else {
     // This is not an outlined function region - need to call __kmpc_int32
CGOpenMPRuntime::CreateRuntimeFunction(OpenMPRTLFunction Function) {
   case OMPRTL__kmpc_end_master: {
     // Build void __kmpc_end_master(ident_t *loc, kmp_int32 global_tid);
     llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
     llvm::FunctionType *FnTy =
         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
     RTLFn = CGM.CreateRuntimeFunction(FnTy, /*Name=*/"__kmpc_end_master");
     break;
   }
+  case OMPRTL__kmpc_omp_task_alloc: {
+    // Build kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32 gtid,
+    // kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
+    // kmp_routine_entry_t *task_entry);
+    llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty, CGM.Int32Ty,
+                                CGM.SizeTy, CGM.SizeTy, KmpRoutineEntryPtrTy};
+    llvm::FunctionType *FnTy = llvm::FunctionType::get(
+        KmpTaskTTy->getPointerTo(), TypeParams, /*isVarArg=*/false);
+    RTLFn = CGM.CreateRuntimeFunction(FnTy, /*Name=*/"__kmpc_omp_task_alloc");
+    break;
+  }
+  case OMPRTL__kmpc_omp_task: {
+    // Build kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid, kmp_task_t
+    // *new_task);
+    llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty,
+                                KmpTaskTTy->getPointerTo()};
+    llvm::FunctionType *FnTy =
+        llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg=*/false);
+    RTLFn = CGM.CreateRuntimeFunction(FnTy, /*Name=*/"__kmpc_omp_task");
+    break;
+  }
   }
   return RTLFn;
 }
 
 llvm::Constant *
 CGOpenMPRuntime::getOrCreateThreadPrivateCache(const VarDecl *VD) {
   // Lookup the entry, lazily creating it if necessary.
   return GetOrCreateInternalVariable(CGM.Int8PtrPtrTy,

 void CGOpenMPRuntime::EmitOMPNumThreadsClause(CodeGenFunction &CGF,
                                               llvm::Value *NumThreads,
                                               SourceLocation Loc) {
   // Build call __kmpc_push_num_threads(&loc, global_tid, num_threads)
   llvm::Value *Args[] = {
       EmitOpenMPUpdateLocation(CGF, Loc), GetOpenMPThreadID(CGF, Loc),
       CGF.Builder.CreateIntCast(NumThreads, CGF.Int32Ty, /*isSigned*/ true)};
   llvm::Constant *RTLFn = CreateRuntimeFunction(OMPRTL__kmpc_push_num_threads);
   CGF.EmitRuntimeCall(RTLFn, Args);
 }
 
 void CGOpenMPRuntime::EmitOMPFlush(CodeGenFunction &CGF, ArrayRef<const Expr *>,
                                    SourceLocation Loc) {
   // Build call void __kmpc_flush(ident_t *loc, ...)
   // FIXME: List of variables is ignored by libiomp5 runtime, no need to
   // generate it, just request full memory fence.
   llvm::Value *Args[] = {EmitOpenMPUpdateLocation(CGF, Loc),
                          llvm::ConstantInt::get(CGM.Int32Ty, 0)};
   auto *RTLFn = CreateRuntimeFunction(OMPRTL__kmpc_flush);
   CGF.EmitRuntimeCall(RTLFn, Args);
 }
+
+namespace {
+/// \brief Fields for type kmp_task_t.
+enum KmpTaskTFields {
+  /// \brief List of shared variables.
+  KmpTaskTShareds,
+  /// \brief Task routine.
+  KmpTaskTRoutine,
+  /// \brief Partition id for the untied tasks.
+  KmpTaskTPartId,
+  /// \brief Function with call of destructors for private variables.
+  KmpTaskTDestructors,
+};
+} // namespace
+
+static RecordDecl *createNewKmpTaskTRecordDecl(ASTContext &C,
+                                               const RecordDecl *RD) {
+  auto *NewRD = C.buildImplicitRecord("kmp_task_t");
+  NewRD->startDefinition();
+  for (auto *FD : RD->fields()) {
+    // Add new field to record.
+    addFieldToRecordDecl(C, NewRD, FD->getType());
+  }
+  return NewRD;
+}
+
+void CGOpenMPRuntime::EmitOMPTaskCall(
+    CodeGenFunction &CGF, SourceLocation Loc, bool Tied,
+    llvm::PointerIntPair<llvm::Value *, 1, bool> Final,
+    llvm::Value *TaskFunction, QualType SharedsTy, llvm::Value *Shareds) {
+  auto &C = CGM.getContext();
+  // Build particular struct kmp_task_t for the given task.
+  auto *KmpTaskRD = createNewKmpTaskTRecordDecl(C, KmpTaskTRD);
+  // TODO: add private fields.
+  KmpTaskRD->completeDefinition();
+  auto KmpTaskQTy = C.getRecordType(KmpTaskRD);
+  auto KmpTaskTySize = CGM.getSize(C.getTypeSizeInChars(KmpTaskQTy));
+  QualType SharedsPtrTy = C.getPointerType(SharedsTy);
+  // Build proxy function which accepts kmp_task_t as the second argument.
+  // kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) {
+  //   TaskFunction(gtid, tt->part_id, tt->shareds);
+  //   return 0;
+  // }
+  auto KmpInt32Ty = C.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/true);
+  QualType KmpTaskPtrQTy = C.getPointerType(KmpTaskQTy);
+  FunctionArgList Args;
+  ImplicitParamDecl GtidArg(C, /*DC=*/nullptr, SourceLocation(),
+                            /*Id=*/nullptr, KmpInt32Ty);
+  ImplicitParamDecl TaskTypeArg(C, /*DC=*/nullptr, SourceLocation(),
+                                /*Id=*/nullptr, KmpTaskPtrQTy);
+  Args.push_back(&GtidArg);
+  Args.push_back(&TaskTypeArg);
+  FunctionType::ExtInfo Info;
+  auto &TaskEntryFnInfo =
+      CGM.getTypes().arrangeFreeFunctionDeclaration(KmpInt32Ty, Args, Info,
+                                                    /*isVariadic=*/false);
+  auto *TaskEntryTy = CGM.getTypes().GetFunctionType(TaskEntryFnInfo);
+  auto *TaskEntry = llvm::Function::Create(
+      TaskEntryTy, /*Linkage=*/llvm::GlobalValue::InternalLinkage,
+      ".omp_task_entry.", &CGM.getModule());
+  CGM.SetLLVMFunctionAttributes(/*D=*/nullptr, TaskEntryFnInfo, TaskEntry);
+  CodeGenFunction TaskEntryCGF(CGM);
+  TaskEntryCGF.StartFunction(GlobalDecl(), KmpInt32Ty, TaskEntry,
+                             TaskEntryFnInfo, Args);
+  // TaskFunction(gtid, tt->part_id, tt->shareds);
+  auto *GtidParam = TaskEntryCGF.EmitLoadOfScalar(
+      TaskEntryCGF.GetAddrOfLocalVar(&GtidArg), /*Volatile=*/false,
+      C.getTypeAlignInChars(KmpInt32Ty).getQuantity(), KmpInt32Ty,
+      SourceLocation());
+  auto TaskTypeArgAddr = TaskEntryCGF.EmitLoadOfScalar(
+      TaskEntryCGF.GetAddrOfLocalVar(&TaskTypeArg), /*Volatile=*/false,
+      CGM.PointerAlignInBytes, KmpTaskPtrQTy, SourceLocation());
+  auto *PartidPtr =
+      TaskEntryCGF.Builder.CreateStructGEP(TaskTypeArgAddr,
+                                           /*Idx=*/KmpTaskTPartId);
+  auto *PartidParam = TaskEntryCGF.EmitLoadOfScalar(
+      PartidPtr, /*Volatile=*/false,
+      C.getTypeAlignInChars(KmpInt32Ty).getQuantity(), KmpInt32Ty,
+      SourceLocation());
+  auto *SharedsPtr =
+      TaskEntryCGF.Builder.CreateStructGEP(TaskTypeArgAddr,
+                                           /*Idx=*/KmpTaskTShareds);
+  auto *SharedsParam = TaskEntryCGF.EmitLoadOfScalar(
+      SharedsPtr, /*Volatile=*/false, CGM.PointerAlignInBytes, C.VoidPtrTy,
+      SourceLocation());
+  llvm::Value *CallArgs[] = {
+      GtidParam, PartidParam,
+      TaskEntryCGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
+          SharedsParam, TaskEntryCGF.ConvertTypeForMem(SharedsPtrTy))};
+  TaskEntryCGF.EmitCallOrInvoke(TaskFunction, CallArgs);
+  TaskEntryCGF.EmitStoreThroughLValue(
+      RValue::get(TaskEntryCGF.Builder.getInt32(/*C=*/0)),
+      TaskEntryCGF.MakeNaturalAlignAddrLValue(TaskEntryCGF.ReturnValue,
+                                              KmpInt32Ty));
+  TaskEntryCGF.FinishFunction(SourceLocation());
+  // Build call kmp_task_t * __kmpc_omp_task_alloc(ident_t *, kmp_int32 gtid,
+  // kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
+  // kmp_routine_entry_t *task_entry);
+  // Task flags. Format is taken from
+  // http://llvm.org/svn/llvm-project/openmp/trunk/runtime/src/kmp.h,
+  // description of kmp_tasking_flags struct.
+  const unsigned TiedFlag = 0x1;
+  const unsigned FinalFlag = 0x2;
+  unsigned Flags = Tied ? TiedFlag : 0;
+  auto *TaskFlags =
+      Final.getPointer()
+          ? CGF.Builder.CreateSelect(Final.getPointer(),
+                                     CGF.Builder.getInt32(FinalFlag),
+                                     CGF.Builder.getInt32(/*C=*/0))
+          : CGF.Builder.getInt32(Final.getInt() ? FinalFlag : 0);
+  TaskFlags = CGF.Builder.CreateOr(TaskFlags, CGF.Builder.getInt32(Flags));
+  auto SharedsSize = C.getTypeSizeInChars(SharedsTy);
+  llvm::Value *AllocArgs[] = {EmitOpenMPUpdateLocation(CGF, Loc),
+                              GetOpenMPThreadID(CGF, Loc), TaskFlags,
+                              KmpTaskTySize, CGM.getSize(SharedsSize),
+                              CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
+                                  TaskEntry, KmpRoutineEntryPtrTy)};
+  auto *RTLFn = CreateRuntimeFunction(OMPRTL__kmpc_omp_task_alloc);
+  auto *NewTask = CGF.EmitRuntimeCall(RTLFn, AllocArgs);
+  auto *NewTaskNewTaskTTy = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
+      NewTask, KmpTaskTTy->getPointerTo());
+  // Fill the data in the resulting kmp_task_t record.
+  // Copy shareds if there are any.
+  if (!SharedsTy->getAsStructureType()->getDecl()->field_empty())
+    CGF.EmitAggregateCopy(
+        CGF.EmitLoadOfScalar(
+            CGF.Builder.CreateStructGEP(NewTaskNewTaskTTy,
+                                        /*Idx=*/KmpTaskTShareds),
+            /*Volatile=*/false, CGM.PointerAlignInBytes, SharedsPtrTy,
+            SourceLocation()),
+        Shareds, SharedsTy);
+  // TODO: generate function with destructors for privates.
+  // Provide pointer to function with destructors for privates.
+  auto DestructorsType =
+      std::next(KmpTaskRD->field_begin(), KmpTaskTDestructors)->getType();
+  CGF.EmitStoreOfScalar(
+      llvm::ConstantPointerNull::get(
+          cast<llvm::PointerType>(CGF.ConvertType(DestructorsType))),
+      CGF.Builder.CreateStructGEP(NewTaskNewTaskTTy,
+                                  /*Idx=*/KmpTaskTDestructors),
+      /*Volatile=*/false, CGM.PointerAlignInBytes, DestructorsType);
+  // NOTE: routine and part_id fields are intialized by __kmpc_omp_task_alloc()
+  // libcall.
+  // Build kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32 gtid, kmp_task_t
+  // *new_task);
+  llvm::Value *TaskArgs[] = {EmitOpenMPUpdateLocation(CGF, Loc),
+                             GetOpenMPThreadID(CGF, Loc), NewTask};
+  RTLFn = CreateRuntimeFunction(OMPRTL__kmpc_omp_task);
+  CGF.EmitRuntimeCall(RTLFn, TaskArgs);
+}
+

lib/CodeGen/CGStmtOpenMP.cpp

void CodeGenFunction::EmitOMPParallelForSimdDirective(
   llvm_unreachable("CodeGen for 'omp parallel for simd' is not supported yet.");
 }
 
 void CodeGenFunction::EmitOMPParallelSectionsDirective(
     const OMPParallelSectionsDirective &) {
   llvm_unreachable("CodeGen for 'omp parallel sections' is not supported yet.");
 }
 
-void CodeGenFunction::EmitOMPTaskDirective(const OMPTaskDirective &) {
-  llvm_unreachable("CodeGen for 'omp task' is not supported yet.");
+void CodeGenFunction::EmitOMPTaskDirective(const OMPTaskDirective &S) {
+  // Emit outlined function for task construct.
+  auto CS = cast<CapturedStmt>(S.getAssociatedStmt());
+  auto CapturedStruct = GenerateCapturedStmtArgument(*CS);
+  auto *I = CS->getCapturedDecl()->param_begin();
+  // The first function argument for tasks is a thread id, the second one is a
+  // part id (0 for tied tasks, >=0 for untied task).
+  auto OutlinedFn =
+      CGM.getOpenMPRuntime().EmitOpenMPOutlinedFunction(S, *I, *std::next(I));
+  // Check if we should emit tied or untied task.
+  bool Tied = !S.getSingleClause(/*K=*/OMPC_untied);
+  // Check if the task is final
+  llvm::PointerIntPair<llvm::Value *, 1, bool> Final;
+  if (auto *Clause = S.getSingleClause(/*K=*/OMPC_final)) {
+    // If the condition constant folds and can be elided, try to avoid emitting
+    // the condition and the dead arm of the if/else.
+    auto *Cond = cast<OMPFinalClause>(Clause)->getCondition();
+    bool CondConstant;
+    if (ConstantFoldsToSimpleInteger(Cond, CondConstant))
+      Final.setInt(CondConstant);
+    else
+      Final.setPointer(EvaluateExprAsBool(Cond));
+  } else
+    // By default the task is not final.
+    Final.setInt(/*IntVal=*/false);
+  auto SharedsTy = getContext().getRecordType(CS->getCapturedRecordDecl());
+  CGM.getOpenMPRuntime().EmitOMPTaskCall(*this, S.getLocStart(), Tied, Final,
+                                         OutlinedFn, SharedsTy, CapturedStruct);
 }
 
 void CodeGenFunction::EmitOMPTaskyieldDirective(const OMPTaskyieldDirective &) {
   llvm_unreachable("CodeGen for 'omp taskyield' is not supported yet.");
 }
 
 void CodeGenFunction::EmitOMPBarrierDirective(const OMPBarrierDirective &S) {
   CGM.getOpenMPRuntime().EmitOMPBarrierCall(*this, S.getLocStart());

lib/Sema/SemaOpenMP.cpp

case DSA_unspecified:
 
     // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
     // in a Construct, implicitly determined, p.4]
     //  In a task construct, if no default clause is present, a variable that in
     //  the enclosing context is determined to be shared by all implicit tasks
     //  bound to the current team is shared.
     if (DVar.DKind == OMPD_task) {
       DSAVarData DVarTemp;
-      for (StackTy::reverse_iterator I = std::next(Iter),
-                                     EE = std::prev(Stack.rend());
+      for (StackTy::reverse_iterator I = std::next(Iter), EE = Stack.rend();
            I != EE; ++I) {
         // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables
         // Referenced
         // in a Construct, implicitly determined, p.6]
         //  In a task construct, if no default clause is present, a variable
         //  whose data-sharing attribute is not determined by the rules above is
         //  firstprivate.
         DVarTemp = getDSA(I, D);
case OMPD_parallel_sections: {
     Sema::CapturedParamNameType Params[] = {
         std::make_pair(StringRef(), QualType()) // __context with shared vars
     };
     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
                              Params);
     break;
   }
   case OMPD_task: {
+    QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1);
     Sema::CapturedParamNameType Params[] = {
+        std::make_pair(".global_tid.", KmpInt32Ty),
+        std::make_pair(".part_id.", KmpInt32Ty),
         std::make_pair(StringRef(), QualType()) // __context with shared vars
     };
     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
                              Params);
+    // Mark this captured region as inlined, because we don't use outlined
+    // function directly.
+    getCurCapturedRegion()->TheCapturedDecl->addAttr(
+        AlwaysInlineAttr::CreateImplicit(
+            Context, AlwaysInlineAttr::Keyword_forceinline, SourceRange()));
     break;
   }
   case OMPD_ordered: {
     Sema::CapturedParamNameType Params[] = {
         std::make_pair(StringRef(), QualType()) // __context with shared vars
     };
     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
                              Params);

test/OpenMP/task_codegen.cpp

+// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp=libiomp5 -x c++ -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -triple x86_64-apple-darwin10 -emit-pch -o %t %s
+// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -triple x86_64-apple-darwin10 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
+// expected-no-diagnostics
+
+#ifndef HEADER
+#define HEADER
+
+// CHECK-DAG: [[IDENT_T:%.+]] = type { i32, i32, i32, i32, i8* }
+// CHECK-DAG: [[STRUCT_SHAREDS:%.+]] = type { i8*, [[STRUCT_S:%.+]]* }
+// CHECK-DAG: [[KMP_TASK_T:%.+]] = type { i8*, i32 (i32, i8*)*, i32, i32 (i32, i8*)* }
+struct S {
+  int a;
+  S() : a(0) {}
+  S(const S &s) : a(s.a) {}
+  ~S() {}
+};
+int a;
+// CHECK-LABEL : @main
+int main() {
+// CHECK: [[B:%.+]] = alloca i8
+// CHECK: [[S:%.+]] = alloca [[STRUCT_S]]
+  char b;
+  S s;
+// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T]]* @{{.+}})
+// CHECK: [[B_REF:%.+]] = getelementptr inbounds [[STRUCT_SHAREDS]]* [[CAPTURES:%.+]], i32 0, i32 0
+// CHECK: store i8* [[B]], i8** [[B_REF]]
+// CHECK: [[S_REF:%.+]] = getelementptr inbounds [[STRUCT_SHAREDS]]* [[CAPTURES]], i32 0, i32 1
+// CHECK: store [[STRUCT_S]]* [[S]], [[STRUCT_S]]** [[S_REF]]
+// CHECK: [[TASK_PTR:%.+]] = call [[KMP_TASK_T]]* @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 1, i64 32, i64 16, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.+}}*)* [[TASK_ENTRY1:@.+]] to i32 (i32, i8*)*))
+// CHECK: [[SHAREDS_REF_PTR:%.+]] = getelementptr inbounds [[KMP_TASK_T]]* [[TASK_PTR:%.+]], i32 0, i32 0
+// CHECK: [[SHAREDS_REF:%.+]] = load i8** [[SHAREDS_REF_PTR]]
+// CHECK: [[BITCAST:%.+]] = bitcast [[STRUCT_SHAREDS]]* [[CAPTURES]] to i8*
+// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[SHAREDS_REF]], i8* [[BITCAST]], i64 16, i32 8, i1 false)
+// CHECK: [[DESTRUCTORS_REF_PTR:%.+]] = getelementptr inbounds [[KMP_TASK_T]]* [[TASK_PTR]], i32 0, i32 3
+// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)** [[DESTRUCTORS_REF_PTR]]
+// CHECK: call i32 @__kmpc_omp_task([[IDENT_T]]* @{{.+}}, i32 [[GTID]], [[KMP_TASK_T]]* [[TASK_PTR]])
+#pragma omp task shared(a, b, s)
+  {
+    a = 15;
+    b = a;
+    s.a = 10;
+  }
+// CHECK: [[TASK_PTR:%.+]] = call [[KMP_TASK_T]]* @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 0, i64 32, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.+}}*)* [[TASK_ENTRY2:@.+]] to i32 (i32, i8*)*))
+// CHECK: [[DESTRUCTORS_REF_PTR:%.+]] = getelementptr inbounds [[KMP_TASK_T]]* [[TASK_PTR]], i32 0, i32 3
+// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)** [[DESTRUCTORS_REF_PTR]]
+// CHECK: call i32 @__kmpc_omp_task([[IDENT_T]]* @{{.+}}, i32 [[GTID]], [[KMP_TASK_T]]* [[TASK_PTR]])
+#pragma omp task untied
+  {
+    a = 1;
+  }
+// CHECK: [[TASK_PTR:%.+]] = call [[KMP_TASK_T]]* @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 3, i64 32, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.+}}*)* [[TASK_ENTRY3:@.+]] to i32 (i32, i8*)*))
+// CHECK: [[DESTRUCTORS_REF_PTR:%.+]] = getelementptr inbounds [[KMP_TASK_T]]* [[TASK_PTR]], i32 0, i32 3
+// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)** [[DESTRUCTORS_REF_PTR]]
+// CHECK: call i32 @__kmpc_omp_task([[IDENT_T]]* @{{.+}}, i32 [[GTID]], [[KMP_TASK_T]]* [[TASK_PTR]])
+#pragma omp task final(true)
+  {
+    a = 2;
+  }
+// CHECK: [[TASK_PTR:%.+]] = call [[KMP_TASK_T]]* @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 1, i64 32, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.+}}*)* [[TASK_ENTRY4:@.+]] to i32 (i32, i8*)*))
+// CHECK: [[DESTRUCTORS_REF_PTR:%.+]] = getelementptr inbounds [[KMP_TASK_T]]* [[TASK_PTR]], i32 0, i32 3
+// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)** [[DESTRUCTORS_REF_PTR]]
+// CHECK: call i32 @__kmpc_omp_task([[IDENT_T]]* @{{.+}}, i32 [[GTID]], [[KMP_TASK_T]]* [[TASK_PTR]])
+  const bool flag = false;
+#pragma omp task final(flag)
+  {
+    a = 3;
+  }
+// CHECK: [[B_VAL:%.+]] = load i8* [[B]]
+// CHECK: [[CMP:%.+]] = icmp ne i8 [[B_VAL]], 0
+// CHECK: [[FINAL:%.+]] = select i1 [[CMP]], i32 2, i32 0
+// CHECK: [[FLAGS:%.+]] = or i32 [[FINAL]], 1
+// CHECK: [[TASK_PTR:%.+]] = call [[KMP_TASK_T]]* @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 [[FLAGS]], i64 32, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.+}}*)* [[TASK_ENTRY5:@.+]] to i32 (i32, i8*)*))
+// CHECK: [[DESTRUCTORS_REF_PTR:%.+]] = getelementptr inbounds [[KMP_TASK_T]]* [[TASK_PTR]], i32 0, i32 3
+// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)** [[DESTRUCTORS_REF_PTR]]
+// CHECK: call i32 @__kmpc_omp_task([[IDENT_T]]* @{{.+}}, i32 [[GTID]], [[KMP_TASK_T]]* [[TASK_PTR]])
+#pragma omp task final(b)
+  {
+    a = 4;
+  }
+  return a;
+}
+// CHECK: define internal i32 [[TASK_ENTRY1]](i32, [[KMP_TASK_T]]{{.+}}*)
+// CHECK: store i32 15, i32* [[A_PTR:@.+]]
+// CHECK: [[A_VAL:%.+]] = load i32* [[A_PTR]]
+// CHECK: [[A_VAL_I8:%.+]] = trunc i32 [[A_VAL]] to i8
+// CHECK: store i8 [[A_VAL_I8]], i8* %{{.+}}
+// CHECK: store i32 10, i32* %{{.+}}
+
+// CHECK: define internal i32 [[TASK_ENTRY2]](i32, [[KMP_TASK_T]]{{.+}}*)
+// CHECK: store i32 1, i32* [[A_PTR:@.+]]
+
+// CHECK: define internal i32 [[TASK_ENTRY3]](i32, [[KMP_TASK_T]]{{.+}}*)
+// CHECK: store i32 2, i32* [[A_PTR:@.+]]
+
+// CHECK: define internal i32 [[TASK_ENTRY4]](i32, [[KMP_TASK_T]]{{.+}}*)
+// CHECK: store i32 3, i32* [[A_PTR:@.+]]
+
+// CHECK: define internal i32 [[TASK_ENTRY5]](i32, [[KMP_TASK_T]]{{.+}}*)
+// CHECK: store i32 4, i32* [[A_PTR:@.+]]
+#endif
+