[OpenMP 4.0]Parsing and Sema support for 'omp declare target' directive (accelerator support)

[ABataev]

Summary

Add parsing, sema analysis for 'declare target' construct for OpenMP 4.0.
Summary
The declare target directive specifies that variables, functions (C, C++ and
Fortran), and subroutines (Fortran) are mapped to a device. The declare target
directive is a declarative directive.

The syntax of the declare target directive is as follows:
For variables, functions and subroutines:

#pragma omp declare target new-line
declarations-definition-seq
#pragma omp end declare target new-line

Codegen will be done in a separate delivery. This is based on the clang-omp github branch adapted for 3.8.
All unit tests passes (note that message test needed to add -fnoopenmp-use-tls to pass specifically the threadprivate part because use-tls is now set to default). All regression passes.
OpenMP 4.5 changes will be delivered separately.

[ABataev]

Michael, please provide full diff log, as described in http://llvm.org/docs/Phabricator.html (with full context)

[ABataev]

I think we'd better to try to use attributes for declare target. I think it will be much easier and correct solution rather than adding a new declaration

include/clang/AST/DeclBase.h

164

I don't think this is required, revert it back please

include/clang/AST/DeclOpenMP.h

18–21

Again, I don't think this change is required. You don't use neither Exprs, nor Types in your changes below

98

I'm not sure that we need to add this kind of declaration. Most probably it is enough just to have an attribute

include/clang/Basic/DiagnosticSemaKinds.td

7751

I don't think that OpenMPClauses is suitable warning group for this warning. Maybe you need to add a new one, for example, target specific

include/clang/Basic/OpenMPKinds.h

30 ↗

(On Diff #42130)

OMPD_empty is not required, this must be deleted

lib/AST/Decl.cpp

21

Do you really need this header file here?

lib/AST/DeclBase.cpp

653

The change is not properly formatted

lib/AST/DeclOpenMP.cpp

10

comma?

lib/AST/DeclPrinter.cpp

95

Not formatted

lib/AST/ItaniumMangle.cpp

23

I don't think this header file is required

lib/AST/MicrosoftMangle.cpp

22

Again, Are you sure this is required?

lib/CodeGen/CGDecl.cpp

1873–1874

There is no such object

lib/CodeGen/CodeGenModule.h

1067–1102

No, this must be deleted. We don't use it here

lib/Parse/ParseDecl.cpp

3624

Restore original line

lib/Parse/ParseOpenMP.cpp

36–39

Formatting broken

58–63

Formatting

80–83

Formatting

209

Do not add default:, coding standard recommends to not use it

387–392

Do not add it

394

Restore original

lib/Sema/SemaExpr.cpp

13566–13568

Formatting. Remove braces

lib/Sema/SemaOpenMP.cpp

1139–1140

I don't understand why you changed this.

1414–1415

Why you need this declaration if earlier you have a definition?

lib/Serialization/ASTReaderDecl.cpp

353

Formatting

2411

Formatting

3307–3309

Formatting

lib/Serialization/ASTWriterDecl.cpp

134

Formatting

[• fraggamuffin]

In D15321#304557, @ABataev wrote:

Michael, please provide full diff log, as described in http://llvm.org/docs/Phabricator.html (with full context)

Ok, no problem. Sorry I forgot. Thanks for the quick review. I only have the other 2 parts to address which is the attribute suggestion and the Helper class which you said should be removed. Thanks again.

include/clang/AST/DeclBase.h

164

This was there before. I am assuming you just want me to revert back the comma. Done.

lib/Parse/ParseOpenMP.cpp

209

This is needed to generate these error messages in declare_target_messages.cpp
error: 'error' diagnostics expected but not seen:

File C:\llvm151206\llvm\tools\clang\test\OpenMP\declare_target_messages.cpp Li

ne 3: unexpected OpenMP directive '#pragma omp end declare target'

File C:\llvm151206\llvm\tools\clang\test\OpenMP\declare_target_messages.cpp Li

ne 63: unexpected OpenMP directive '#pragma omp end declare target'

File C:\llvm151206\llvm\tools\clang\test\OpenMP\declare_target_messages.cpp Li

ne 72: unexpected OpenMP directive '#pragma omp end declare target'
3 errors generated.

387–392

This is needed to prevent infinite loop when there is an unexpected end of the pragma omp target.

lib/Sema/SemaOpenMP.cpp

1139–1140

The buildDeclRefExpr interface does not enable us to generate these messages.
Someone changed it to buildDeclRefExpr(...) which has a different interface
In the github repository it also uses
ExprResult DE = BuildDeclRefExpr(VD, ExprType, VK_LValue, Id.getLoc());

With the buildDeclRefExpr interface, it misses generation of these messages
error: 'warning' diagnostics expected but not seen:

File C:\llvm151206\llvm\tools\clang\test\OpenMP\declare_target_messages.cpp Li

ne 5: declaration is not declared in any declare target region
error: 'note' diagnostics expected but not seen:

File C:\llvm151206\llvm\tools\clang\test\OpenMP\declare_target_messages.cpp Li

ne 21: used here
2 errors generated.

[• fraggamuffin]

This is just an interim full diff file of changes accepted so far. I still need to address the attribute and Helper class comment. Thanks.

[ABataev]

lib/Parse/ParseOpenMP.cpp

209

Still 'default:' is a bad solution. You must explicitly take all possible cases for the enumeric type

387–392

As I said before 'default:' is a bad solution. Add explicit cases for all possible values

lib/Sema/SemaOpenMP.cpp

1139–1140

Github is not a reference version, it has many very bad and not working solutions. You don't need take everything from there, some solutions are just not compatible with trunk

[• fraggamuffin]

Thanks for the pre-xmas review.

include/clang/AST/DeclOpenMP.h

98

I added attributes in a few places according to what was done with threadprivate but I am not sure it is enough.

lib/Parse/ParseOpenMP.cpp

209

I agree and see your point. Thanks. I fixed it by adding the search for end declare target.

387–392

I agree and see your point. Thanks. I fixed it .

lib/Sema/SemaOpenMP.cpp

1139–1140

OK, I looked at the uses of build.. and Build.. and see that build... is only used within SemaOpenMP.cpp, so I changed it back, and added my check inside build... for when it is in a target region. Thanks.

[• fraggamuffin]

Fixed Comments from Dec 17.

[ABataev]

Hello Michael,
Thanks for working on this. I still think we don't need OMPDeclareTargetDecl here and we can handle everything with an attribute. Try to implement everything just with an attribute and without OMPDeclareTargetDecl.

[ABataev]

Revision is abandoned as the construct is supported already.

include/clang/AST/DeclBase.h

enum IdentifierNamespace {
     /// This declaration is a C++ operator declared in a non-class
     /// context.  All such operators are also in IDNS_Ordinary.
     /// C++ lexical operator lookup looks for these.
     IDNS_NonMemberOperator   = 0x0400,
 
     /// This declaration is a function-local extern declaration of a
     /// variable or function. This may also be IDNS_Ordinary if it
     /// has been declared outside any function.
     IDNS_LocalExtern         = 0x0800
   };
 
   /// ObjCDeclQualifier - 'Qualifiers' written next to the return and
   /// parameter types in method declarations.  Other than remembering
   /// them and mangling them into the method's signature string, these
   /// are ignored by the compiler; they are consumed by certain
   /// remote-messaging frameworks.
   ///
public:
   bool isFileContext() const {
     return DeclKind == Decl::TranslationUnit || DeclKind == Decl::Namespace;
   }
 
   bool isTranslationUnit() const {
     return DeclKind == Decl::TranslationUnit;
   }
 
+  bool isOMPDeclareTarget() const { return DeclKind == Decl::OMPDeclareTarget; }
+
+  bool isTranslationUnitOrDeclareTarget() const {
+    return isOMPDeclareTarget() || isTranslationUnit();
+  }
+
   bool isRecord() const {
     return DeclKind >= Decl::firstRecord && DeclKind <= Decl::lastRecord;
   }
 
   bool isNamespace() const {
     return DeclKind == Decl::Namespace;
   }
 

include/clang/AST/DeclOpenMP.h

 /// \file
 /// \brief This file defines OpenMP nodes for declarative directives.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_DECLOPENMP_H
 #define LLVM_CLANG_AST_DECLOPENMP_H
 
-#include "clang/AST/DeclBase.h"
+#include "clang/AST/Decl.h"
 #include "llvm/ADT/ArrayRef.h"
 
 namespace clang {
 class Expr;
 
 /// \brief This represents '#pragma omp threadprivate ...' directive.
 /// For example, in the following, both 'a' and 'A::b' are threadprivate:
 ///
 /// \code
 /// int a;
 /// #pragma omp threadprivate(a)
public:
   varlist_iterator varlist_end() { return getVars().end(); }
   varlist_const_iterator varlist_begin() const { return getVars().begin(); }
   varlist_const_iterator varlist_end() const { return getVars().end(); }
 
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == OMPThreadPrivate; }
 };
 
+/// For example, in the following, declared target variable 'foo':
+///
+/// \code
+/// #pragma omp declare target
+/// int foo;
+/// #pragma omp end declare target
+/// \endcode
+///
+class OMPDeclareTargetDecl : public Decl, public DeclContext {
+  friend class ASTDeclReader;
+
+  virtual void anchor();
+
+  OMPDeclareTargetDecl(Kind DK, DeclContext *DC, SourceLocation L)
+    : Decl(DK, DC, L), DeclContext(DK) {
+    setModulePrivate();
+  }
+
+public:
+  static OMPDeclareTargetDecl *Create(ASTContext &C, DeclContext *DC,
+    SourceLocation L);
+  static OMPDeclareTargetDecl *CreateDeserialized(ASTContext &C, unsigned ID);
+
+  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
+  static bool classofKind(Kind K) { return K == OMPDeclareTarget; }
+  static DeclContext *castToDeclContext(const OMPDeclareTargetDecl *D) {
+    return static_cast<DeclContext *>(const_cast<OMPDeclareTargetDecl *>(D));
+  }
+  static OMPDeclareTargetDecl *castFromDeclContext(const DeclContext *DC) {
+    return static_cast<OMPDeclareTargetDecl *>(const_cast<DeclContext *>(DC));
+  }
+};
+
 }  // end namespace clang
 
 #endif

include/clang/AST/RecursiveASTVisitor.h

 DEF_TRAVERSE_DECL(UsingShadowDecl, {})
 
 DEF_TRAVERSE_DECL(OMPThreadPrivateDecl, {
   for (auto *I : D->varlists()) {
     TRY_TO(TraverseStmt(I));
   }
 })
 
+DEF_TRAVERSE_DECL(OMPDeclareTargetDecl, {})
+
 // A helper method for TemplateDecl's children.
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseTemplateParameterListHelper(
     TemplateParameterList *TPL) {
   if (TPL) {
     for (TemplateParameterList::iterator I = TPL->begin(), E = TPL->end();
          I != E; ++I) {
       TRY_TO(TraverseDecl(*I));

include/clang/Basic/Attr.td

 
 def OMPThreadPrivateDecl : InheritableAttr {
   // This attribute has no spellings as it is only ever created implicitly.
   let Spellings = [];
   let SemaHandler = 0;
   let Documentation = [Undocumented];
 }
 
+def OMPDeclareTargetDecl : InheritableAttr {
+  // This attribute has no spellings as it is only ever created implicitly.
+  let Spellings = [];
+  let SemaHandler = 0;
+  let Documentation = [Undocumented];
+}
+
 def InternalLinkage : InheritableAttr {
   let Spellings = [GNU<"internal_linkage">, CXX11<"clang", "internal_linkage">];
   let Subjects = SubjectList<[Var, Function, CXXRecord]>;
   let Documentation = [InternalLinkageDocs];
 }

include/clang/Basic/DeclNodes.td

 def Friend : Decl;
 def FriendTemplate : Decl;
 def StaticAssert : Decl;
 def Block : Decl, DeclContext;
 def Captured : Decl, DeclContext;
 def ClassScopeFunctionSpecialization : Decl;
 def Import : Decl;
 def OMPThreadPrivate : Decl;
+def OMPDeclareTarget : Decl, DeclContext;
 def Empty : Decl;
 

include/clang/Basic/DiagnosticGroups.td

 def ASM : DiagGroup<"asm", [
     ASMOperandWidths
   ]>;
 
 // OpenMP warnings.
 def SourceUsesOpenMP : DiagGroup<"source-uses-openmp">;
 def OpenMPClauses : DiagGroup<"openmp-clauses">;
 def OpenMPLoopForm : DiagGroup<"openmp-loop-form">;
+def OpenMPTarget : DiagGroup<"openmp-target">;
 
 // Backend warnings.
 def BackendInlineAsm : DiagGroup<"inline-asm">;
 def BackendFrameLargerThanEQ : DiagGroup<"frame-larger-than=">;
 def BackendPlugin : DiagGroup<"backend-plugin">;
 def RemarkBackendPlugin : DiagGroup<"remark-backend-plugin">;
 def BackendOptimizationRemark : DiagGroup<"pass">;
 def BackendOptimizationRemarkMissed : DiagGroup<"pass-missed">;

include/clang/Basic/DiagnosticParseKinds.td

 def err_omp_expected_punc : Error<
   "expected ',' or ')' in '%0' %select{clause|directive}1">;
 def err_omp_unexpected_clause : Error<
   "unexpected OpenMP clause '%0' in directive '#pragma omp %1'">;
 def err_omp_immediate_directive : Error<
   "'#pragma omp %0' cannot be an immediate substatement">;
 def err_omp_expected_identifier_for_critical : Error<
   "expected identifier specifying the name of the 'omp critical' directive">;
+def err_expected_end_declare_target : Error<
+  "expected '#pragma omp end declare target'">;
 def err_omp_unknown_map_type : Error<
   "incorrect map type, expected one of 'to', 'from', 'tofrom', 'alloc', 'release', or 'delete'">;
 def err_omp_unknown_map_type_modifier : Error<
   "incorrect map type modifier, expected 'always'">;
 def err_omp_map_type_missing : Error<
   "missing map type">;
 
 // Pragma loop support.

include/clang/Basic/DiagnosticSemaKinds.td

def err_omp_expected_var_arg : Error<
   "%0 is not a global variable, static local variable or static data member">;
 def err_omp_expected_var_arg_suggest : Error<
   "%0 is not a global variable, static local variable or static data member; "
   "did you mean %1">;
 def err_omp_global_var_arg : Error<
   "arguments of '#pragma omp %0' must have %select{global storage|static storage duration}1">;
 def err_omp_ref_type_arg : Error<
   "arguments of '#pragma omp %0' cannot be of reference type %1">;
+def err_omp_region_not_file_context : Error<
+  "directive must be at file or namespace scope">;
 def err_omp_var_scope : Error<
   "'#pragma omp %0' must appear in the scope of the %q1 variable declaration">;
 def err_omp_var_used : Error<
   "'#pragma omp %0' must precede all references to variable %q1">;
 def err_omp_var_thread_local : Error<
   "variable %0 cannot be threadprivate because it is %select{thread-local|a global named register variable}1">;
 def err_omp_private_incomplete_type : Error<
   "a private variable with incomplete type %0">;
def err_omp_not_for : Error<
   "expected %2 for loops after '#pragma omp %1'%select{|, but found only %4}3}0">;
 def note_omp_collapse_ordered_expr : Note<
   "as specified in %select{'collapse'|'ordered'|'collapse' and 'ordered'}0 clause%select{||s}0">;
 def err_omp_negative_expression_in_clause : Error<
   "argument to '%0' clause must be a %select{non-negative|strictly positive}1 integer value">;
 def err_omp_not_integral : Error<
   "expression must have integral or unscoped enumeration "
   "type, not %0">;
+def err_omp_threadprivate_in_target : Error<
+  "threadprivate variables cannot be used in target constructs">;
 def err_omp_incomplete_type : Error<
   "expression has incomplete class type %0">;
 def err_omp_explicit_conversion : Error<
   "expression requires explicit conversion from %0 to %1">;
 def note_omp_conversion_here : Note<
   "conversion to %select{integral|enumeration}0 type %1 declared here">;
 def err_omp_ambiguous_conversion : Error<
   "ambiguous conversion from type %0 to an integral or unscoped "
def err_omp_linear_expected_int_or_ptr : Error<
   "argument of a linear clause should be of integral or pointer "
   "type, not %0">;
 def warn_omp_linear_step_zero : Warning<
   "zero linear step (%0 %select{|and other variables in clause }1should probably be const)">,
   InGroup<OpenMPClauses>;
 def warn_omp_alignment_not_power_of_two : Warning<
   "aligned clause will be ignored because the requested alignment is not a power of 2">,
   InGroup<OpenMPClauses>;
+def warn_omp_not_in_target_context : Warning<
+  "declaration is not declared in any declare target region">,
+  InGroup<OpenMPTarget>;
 def err_omp_aligned_expected_array_or_ptr : Error<
   "argument of aligned clause should be array"
   "%select{ or pointer|, pointer, reference to array or reference to pointer}1"
   ", not %0">;
 def err_omp_aligned_twice : Error<
   "a variable cannot appear in more than one aligned clause">;
 def err_omp_local_var_in_threadprivate_init : Error<
   "variable with local storage in initial value of threadprivate variable">;

include/clang/Basic/OpenMPKinds.def

 OPENMP_DIRECTIVE_EXT(target_data, "target data")
 OPENMP_DIRECTIVE_EXT(parallel_for, "parallel for")
 OPENMP_DIRECTIVE_EXT(parallel_for_simd, "parallel for simd")
 OPENMP_DIRECTIVE_EXT(parallel_sections, "parallel sections")
 OPENMP_DIRECTIVE_EXT(for_simd, "for simd")
 OPENMP_DIRECTIVE_EXT(cancellation_point, "cancellation point")
 OPENMP_DIRECTIVE(taskloop)
 OPENMP_DIRECTIVE_EXT(taskloop_simd, "taskloop simd")
+OPENMP_DIRECTIVE_EXT(declare_target, "declare target")
+OPENMP_DIRECTIVE_EXT(end_declare_target, "end declare target")
 
 // OpenMP clauses.
 OPENMP_CLAUSE(if, OMPIfClause)
 OPENMP_CLAUSE(final, OMPFinalClause)
 OPENMP_CLAUSE(num_threads, OMPNumThreadsClause)
 OPENMP_CLAUSE(safelen, OMPSafelenClause)
 OPENMP_CLAUSE(simdlen, OMPSimdlenClause)
 OPENMP_CLAUSE(collapse, OMPCollapseClause)

include/clang/Parse/Parser.h

bool ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
                                     bool AssumeTemplateId);
   bool ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
                                   ParsedType ObjectType,
                                   UnqualifiedId &Result);
 
   //===--------------------------------------------------------------------===//
   // OpenMP: Directives and clauses.
   /// \brief Parses declarative OpenMP directives.
-  DeclGroupPtrTy ParseOpenMPDeclarativeDirective();
+  DeclGroupPtrTy ParseOpenMPDeclarativeDirective(AccessSpecifier AS);
   /// \brief Parses simple list of variables.
   ///
   /// \param Kind Kind of the directive.
   /// \param [out] VarList List of referenced variables.
   /// \param AllowScopeSpecifier true, if the variables can have fully
   /// qualified names.
   ///
   bool ParseOpenMPSimpleVarList(OpenMPDirectiveKind Kind,

include/clang/Sema/Sema.h

namespace clang {
   class ObjCIvarDecl;
   template <class T> class ObjCList;
   class ObjCMessageExpr;
   class ObjCMethodDecl;
   class ObjCPropertyDecl;
   class ObjCProtocolDecl;
   class OMPThreadPrivateDecl;
   class OMPClause;
+  class OMPDeclareTargetDecl;
   struct OverloadCandidate;
   class OverloadCandidateSet;
   class OverloadExpr;
   class ParenListExpr;
   class ParmVarDecl;
   class Preprocessor;
   class PseudoDestructorTypeStorage;
   class PseudoObjectExpr;
public:
   DeclGroupPtrTy ActOnOpenMPThreadprivateDirective(
                                      SourceLocation Loc,
                                      ArrayRef<Expr *> VarList);
   /// \brief Builds a new OpenMPThreadPrivateDecl and checks its correctness.
   OMPThreadPrivateDecl *CheckOMPThreadPrivateDecl(
                                      SourceLocation Loc,
                                      ArrayRef<Expr *> VarList);
 
+  bool ActOnStartOpenMPDeclareTargetDirective(Scope *S, SourceLocation Loc);
+  void ActOnOpenMPDeclareTargetDecls(DeclGroupPtrTy Decls);
+  DeclGroupPtrTy ActOnFinishOpenMPDeclareTargetDirective();
+  void ActOnOpenMPDeclareTargetDirectiveError();
+  void CheckDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D);
+  bool IsDeclContextInOpenMPTarget(DeclContext *DC);
+
   /// \brief Initialization of captured region for OpenMP region.
   void ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope);
   /// \brief End of OpenMP region.
   ///
   /// \param S Statement associated with the current OpenMP region.
   /// \param Clauses List of clauses for the current OpenMP region.
   ///
   /// \returns Statement for finished OpenMP region.

include/clang/Serialization/ASTBitCodes.h

enum DeclCode {
       /// \brief An ImportDecl recording a module import.
       DECL_IMPORT,
       /// \brief An OMPThreadPrivateDecl record.
       DECL_OMP_THREADPRIVATE,
       /// \brief An EmptyDecl record.
       DECL_EMPTY,
       /// \brief An ObjCTypeParamDecl record.
       DECL_OBJC_TYPE_PARAM,
+      /// \brief An OMPDeclareTargetDecl record.
+      DECL_OMP_DECLARETARGET,
     };
 
     /// \brief Record codes for each kind of statement or expression.
     ///
     /// These constants describe the records that describe statements
     /// or expressions. These records  occur within type and declarations
     /// block, so they begin with record values of 128.  Each constant 
     /// describes a record for a specific statement or expression class in the

lib/AST/ASTContext.cpp

if (VD->getStorageClass() == SC_Register)
       return false;
     if (VD->getDescribedVarTemplate() ||
         isa<VarTemplatePartialSpecializationDecl>(VD))
       return false;
   } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
     // We never need to emit an uninstantiated function template.
     if (FD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate)
       return false;
-  } else if (isa<OMPThreadPrivateDecl>(D))
+  } else if (isa<OMPThreadPrivateDecl>(D) || isa<OMPDeclareTargetDecl>(D))
     return true;
   else
     return false;
 
   // If this is a member of a class template, we do not need to emit it.
   if (D->getDeclContext()->isDependentContext())
     return false;
 

lib/AST/Decl.cpp

 
 #include "clang/AST/Decl.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTLambda.h"
 #include "clang/AST/ASTMutationListener.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/PrettyPrinter.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/Module.h"

 void VarDecl::setStorageClass(StorageClass SC) {
   assert(isLegalForVariable(SC));
   VarDeclBits.SClass = SC;
 }
 
 VarDecl::TLSKind VarDecl::getTLSKind() const {
   switch (VarDeclBits.TSCSpec) {
   case TSCS_unspecified:
-    if (!hasAttr<ThreadAttr>() &&
-        !(getASTContext().getLangOpts().OpenMPUseTLS &&
-          getASTContext().getTargetInfo().isTLSSupported() &&
-          hasAttr<OMPThreadPrivateDeclAttr>()))
+   if (!hasAttr<ThreadAttr>() &&
+       !(getASTContext().getLangOpts().OpenMPUseTLS &&
+       getASTContext().getTargetInfo().isTLSSupported() &&
+       hasAttr<OMPThreadPrivateDeclAttr>()))
        return TLS_None;
-    return ((getASTContext().getLangOpts().isCompatibleWithMSVC(
+   return ((getASTContext().getLangOpts().isCompatibleWithMSVC(
                 LangOptions::MSVC2015)) ||
             hasAttr<OMPThreadPrivateDeclAttr>())
                ? TLS_Dynamic
                : TLS_Static;
   case TSCS___thread: // Fall through.
   case TSCS__Thread_local:
     return TLS_Static;
   case TSCS_thread_local:

 
 bool FunctionDecl::isReservedGlobalPlacementOperator() const {
   assert(getDeclName().getNameKind() == DeclarationName::CXXOperatorName);
   assert(getDeclName().getCXXOverloadedOperator() == OO_New ||
          getDeclName().getCXXOverloadedOperator() == OO_Delete ||
          getDeclName().getCXXOverloadedOperator() == OO_Array_New ||
          getDeclName().getCXXOverloadedOperator() == OO_Array_Delete);
 
-  if (!getDeclContext()->getRedeclContext()->isTranslationUnit())
+  if (!getDeclContext()->getRedeclContext()->isTranslationUnitOrDeclareTarget())
     return false;
 
   const auto *proto = getType()->castAs<FunctionProtoType>();
   if (proto->getNumParams() != 2 || proto->isVariadic())
     return false;
 
   ASTContext &Context =
     cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext())
if (getDeclName().getCXXOverloadedOperator() != OO_New &&
       getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
       getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
     return false;
 
   if (isa<CXXRecordDecl>(getDeclContext()))
     return false;
 
   // This can only fail for an invalid 'operator new' declaration.
-  if (!getDeclContext()->getRedeclContext()->isTranslationUnit())
+  if (!getDeclContext()->getRedeclContext()->isTranslationUnitOrDeclareTarget())
     return false;
 
   const auto *FPT = getType()->castAs<FunctionProtoType>();
   if (FPT->getNumParams() == 0 || FPT->getNumParams() > 2 || FPT->isVariadic())
     return false;
 
   // If this is a single-parameter function, it must be a replaceable global
   // allocation or deallocation function.
for (const FunctionDecl *FD = Redecl->getPreviousDecl(); FD;
     if (!FD->isImplicit() && FD->getStorageClass() == SC_Extern)
       return false;
 
   return true;
 }
 
 static bool RedeclForcesDefC99(const FunctionDecl *Redecl) {
   // Only consider file-scope declarations in this test.
-  if (!Redecl->getLexicalDeclContext()->isTranslationUnit())
+  if (!Redecl->getLexicalDeclContext()->isTranslationUnitOrDeclareTarget())
     return false;
 
   // Only consider explicit declarations; the presence of a builtin for a
   // libcall shouldn't affect whether a definition is externally visible.
   if (Redecl->isImplicit())
     return false;
 
   if (!Redecl->isInlineSpecified() || Redecl->getStorageClass() == SC_Extern) 

lib/AST/DeclBase.cpp

 }
 
 bool Decl::isTemplateDecl() const {
   return isa<TemplateDecl>(this);
 }
 
 const DeclContext *Decl::getParentFunctionOrMethod() const {
   for (const DeclContext *DC = getDeclContext();
-       DC && !DC->isTranslationUnit() && !DC->isNamespace(); 
+       DC && !DC->isTranslationUnitOrDeclareTarget() && !DC->isNamespace();
        DC = DC->getParent())
     if (DC->isFunctionOrMethod())
       return DC;
 
   return nullptr;
 }
 
 
switch (DeclKind) {
     case ClassScopeFunctionSpecialization:
     case VarTemplateSpecialization:
     case VarTemplatePartialSpecialization:
     case ObjCImplementation:
     case ObjCCategory:
     case ObjCCategoryImpl:
     case Import:
     case OMPThreadPrivate:
+    case OMPDeclareTarget:
     case Empty:
       // Never looked up by name.
       return 0;
   }
 
   llvm_unreachable("Invalid DeclKind!");
 }
 
bool DeclContext::isStdNamespace() const {
   if (!isNamespace())
     return false;
 
   const NamespaceDecl *ND = cast<NamespaceDecl>(this);
   if (ND->isInline()) {
     return ND->getParent()->isStdNamespace();
   }
 
-  if (!getParent()->getRedeclContext()->isTranslationUnit())
+  if (!getParent()->getRedeclContext()->isTranslationUnitOrDeclareTarget())
     return false;
 
   const IdentifierInfo *II = ND->getIdentifier();
   return II && II->isStr("std");
 }
 
 bool DeclContext::isDependentContext() const {
   if (isFileContext())
bool DeclContext::isDependentContext() const {
   return getParent() && getParent()->isDependentContext();
 }
 
 bool DeclContext::isTransparentContext() const {
   if (DeclKind == Decl::Enum)
     return !cast<EnumDecl>(this)->isScoped();
   else if (DeclKind == Decl::LinkageSpec)
     return true;
+  else if (DeclKind == Decl::OMPDeclareTarget)
+    return true;
 
   return false;
 }
 
 static bool isLinkageSpecContext(const DeclContext *DC,
                                  LinkageSpecDecl::LanguageIDs ID) {
   while (DC->getDeclKind() != Decl::TranslationUnit) {
     if (DC->getDeclKind() == Decl::LinkageSpec)

 
 DeclContext *DeclContext::getPrimaryContext() {
   switch (DeclKind) {
   case Decl::TranslationUnit:
   case Decl::ExternCContext:
   case Decl::LinkageSpec:
   case Decl::Block:
   case Decl::Captured:
+  case Decl::OMPDeclareTarget:
     // There is only one DeclContext for these entities.
     return this;
 
   case Decl::Namespace:
     // The original namespace is our primary context.
     return static_cast<NamespaceDecl*>(this)->getOriginalNamespace();
 
   case Decl::ObjCMethod:

lib/AST/DeclOpenMP.cpp

 //===--- DeclOpenMP.cpp - Declaration OpenMP AST Node Implementation ------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 /// \file
-/// \brief This file implements OMPThreadPrivateDecl class.
+/// \brief This file implements OMPThreadPrivateDecl, OMPDeclareTarget class.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclOpenMP.h"
 #include "clang/AST/Expr.h"

 
 void OMPThreadPrivateDecl::setVars(ArrayRef<Expr *> VL) {
   assert(VL.size() == NumVars &&
          "Number of variables is not the same as the preallocated buffer");
   Expr **Vars = reinterpret_cast<Expr **>(this + 1);
   std::copy(VL.begin(), VL.end(), Vars);
 }
 
+
+//===----------------------------------------------------------------------===//
+// OMPDeclareTargetDecl Implementation.
+//===----------------------------------------------------------------------===//
+
+void OMPDeclareTargetDecl::anchor() {}
+
+OMPDeclareTargetDecl *
+OMPDeclareTargetDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) {
+  OMPDeclareTargetDecl *D =
+    new (C, DC) OMPDeclareTargetDecl(OMPDeclareTarget, DC, L);
+  return D;
+}
+
+OMPDeclareTargetDecl *OMPDeclareTargetDecl::CreateDeserialized(ASTContext &C,
+  unsigned ID) {
+  // Realign
+  OMPDeclareTargetDecl *D =
+    new (C, ID) OMPDeclareTargetDecl(OMPDeclareTarget, 0, SourceLocation());
+  return D;
+}
 No newline at end of file

lib/AST/DeclPrinter.cpp

public:
     void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
     void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
     void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
     void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
     void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
     void VisitUsingDecl(UsingDecl *D);
     void VisitUsingShadowDecl(UsingShadowDecl *D);
     void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
+    void VisitOMPDeclareTargetDecl(OMPDeclareTargetDecl *D);
 
     void PrintTemplateParameters(const TemplateParameterList *Params,
                                  const TemplateArgumentList *Args = nullptr);
     void prettyPrintAttributes(Decl *D);
     void prettyPrintPragmas(Decl *D);
     void printDeclType(QualType T, StringRef DeclName, bool Pack = false);
   };
 }
if (isa<AccessSpecDecl>(*D)) {
       continue;
     }
 
     this->Indent();
     Visit(*D);
 
     // FIXME: Need to be able to tell the DeclPrinter when
     const char *Terminator = nullptr;
-    if (isa<OMPThreadPrivateDecl>(*D))
+    if (isa<OMPThreadPrivateDecl>(*D) || isa<OMPDeclareTargetDecl>(*D))
       Terminator = nullptr;
     else if (isa<FunctionDecl>(*D) &&
              cast<FunctionDecl>(*D)->isThisDeclarationADefinition())
       Terminator = nullptr;
     else if (isa<ObjCMethodDecl>(*D) && cast<ObjCMethodDecl>(*D)->getBody())
       Terminator = nullptr;
     else if (isa<NamespaceDecl>(*D) || isa<LinkageSpecDecl>(*D) ||
              isa<ObjCImplementationDecl>(*D) ||
if (PDecl->getPropertyAttributes() != ObjCPropertyDecl::OBJC_PR_noattr) {
     Out << " )";
   }
   Out << ' ' << PDecl->getASTContext().getUnqualifiedObjCPointerType(T).
                   getAsString(Policy) << ' ' << *PDecl;
   if (Policy.PolishForDeclaration)
     Out << ';';
 }
 
+void DeclPrinter::VisitOMPDeclareTargetDecl(OMPDeclareTargetDecl *D) {
+  Out << "#pragma omp declare target\n";
+  VisitDeclContext(D);
+  Out << "#pragma omp end declare target\n";
+}
+
 void DeclPrinter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *PID) {
   if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize)
     Out << "@synthesize ";
   else
     Out << "@dynamic ";
   Out << *PID->getPropertyDecl();
   if (PID->getPropertyIvarDecl())
     Out << '=' << *PID->getPropertyIvarDecl();

lib/AST/ItaniumMangle.cpp

 //
 //===----------------------------------------------------------------------===//
 #include "clang/AST/Mangle.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/ABI.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/StringExtras.h"

 }
 
 static bool isLocalContainerContext(const DeclContext *DC) {
   return isa<FunctionDecl>(DC) || isa<ObjCMethodDecl>(DC) || isa<BlockDecl>(DC);
 }
 
 static const RecordDecl *GetLocalClassDecl(const Decl *D) {
   const DeclContext *DC = getEffectiveDeclContext(D);
-  while (!DC->isNamespace() && !DC->isTranslationUnit()) {
+  while (!DC->isNamespace() && !DC->isTranslationUnitOrDeclareTarget()) {
     if (isLocalContainerContext(DC))
       return dyn_cast<RecordDecl>(D);
     D = cast<Decl>(DC);
     DC = getEffectiveDeclContext(D);
   }
   return nullptr;
 }
 
if (VD) {
     // C variables are not mangled.
     if (VD->isExternC())
       return false;
 
     // Variables at global scope with non-internal linkage are not mangled
     const DeclContext *DC = getEffectiveDeclContext(D);
     // Check for extern variable declared locally.
     if (DC->isFunctionOrMethod() && D->hasLinkage())
-      while (!DC->isNamespace() && !DC->isTranslationUnit())
+      while (!DC->isNamespace() && !DC->isTranslationUnitOrDeclareTarget())
         DC = getEffectiveParentContext(DC);
-    if (DC->isTranslationUnit() && D->getFormalLinkage() != InternalLinkage &&
+    if (DC->isTranslationUnitOrDeclareTarget() && D->getFormalLinkage() != InternalLinkage &&
         !isa<VarTemplateSpecializationDecl>(D))
       return false;
   }
 
   return true;
 }
 
 void CXXNameMangler::mangle(const NamedDecl *D) {
static const DeclContext *IgnoreLinkageSpecDecls(const DeclContext *DC) {
   }
 
   return DC;
 }
 
 /// Return whether a given namespace is the 'std' namespace.
 static bool isStd(const NamespaceDecl *NS) {
   if (!IgnoreLinkageSpecDecls(getEffectiveParentContext(NS))
-                                ->isTranslationUnit())
+                                ->isTranslationUnitOrDeclareTarget())
     return false;
   
   const IdentifierInfo *II = NS->getOriginalNamespace()->getIdentifier();
   return II && II->isStr("std");
 }
 
 // isStdNamespace - Return whether a given decl context is a toplevel 'std'
 // namespace.
void CXXNameMangler::mangleName(const NamedDecl *ND) {
   //
   const DeclContext *DC = getEffectiveDeclContext(ND);
 
   // If this is an extern variable declared locally, the relevant DeclContext
   // is that of the containing namespace, or the translation unit.
   // FIXME: This is a hack; extern variables declared locally should have
   // a proper semantic declaration context!
   if (isLocalContainerContext(DC) && ND->hasLinkage() && !isLambda(ND))
-    while (!DC->isNamespace() && !DC->isTranslationUnit())
+    while (!DC->isNamespace() && !DC->isTranslationUnitOrDeclareTarget())
       DC = getEffectiveParentContext(DC);
   else if (GetLocalClassDecl(ND)) {
     mangleLocalName(ND);
     return;
   }
 
   DC = IgnoreLinkageSpecDecls(DC);
 
-  if (DC->isTranslationUnit() || isStdNamespace(DC)) {
+  if (DC->isTranslationUnitOrDeclareTarget() || isStdNamespace(DC)) {
     // Check if we have a template.
     const TemplateArgumentList *TemplateArgs = nullptr;
     if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) {
       mangleUnscopedTemplateName(TD);
       mangleTemplateArgs(*TemplateArgs);
       return;
     }
 
     mangleUnscopedName(ND);
     return;
   }
 
   if (isLocalContainerContext(DC)) {
     mangleLocalName(ND);
     return;
   }
 
   mangleNestedName(ND, DC);
 }
 void CXXNameMangler::mangleName(const TemplateDecl *TD,
                                 const TemplateArgument *TemplateArgs,
                                 unsigned NumTemplateArgs) {
   const DeclContext *DC = IgnoreLinkageSpecDecls(getEffectiveDeclContext(TD));
 
-  if (DC->isTranslationUnit() || isStdNamespace(DC)) {
+  if (DC->isTranslationUnitOrDeclareTarget() || isStdNamespace(DC)) {
     mangleUnscopedTemplateName(TD);
     mangleTemplateArgs(TemplateArgs, NumTemplateArgs);
   } else {
     mangleNestedName(TD, TemplateArgs, NumTemplateArgs);
   }
 }
 
 void CXXNameMangler::mangleUnscopedName(const NamedDecl *ND) {
void CXXNameMangler::manglePrefix(const DeclContext *DC, bool NoFunction) {
   //  <prefix> ::= <prefix> <unqualified-name>
   //           ::= <template-prefix> <template-args>
   //           ::= <template-param>
   //           ::= # empty
   //           ::= <substitution>
 
   DC = IgnoreLinkageSpecDecls(DC);
 
-  if (DC->isTranslationUnit())
+  if (DC->isTranslationUnitOrDeclareTarget())
     return;
 
   if (NoFunction && isLocalContainerContext(DC))
     return;
 
   assert(!isLocalContainerContext(DC));
 
   const NamedDecl *ND = cast<NamedDecl>(DC);  

lib/AST/MicrosoftMangle.cpp

 #include "clang/AST/Mangle.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/VTableBuilder.h"
 #include "clang/Basic/ABI.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/MathExtras.h"
if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
     // C variables are not mangled.
     if (VD->isExternC())
       return false;
 
     // Variables at global scope with non-internal linkage are not mangled.
     const DeclContext *DC = getEffectiveDeclContext(D);
     // Check for extern variable declared locally.
     if (DC->isFunctionOrMethod() && D->hasLinkage())
-      while (!DC->isNamespace() && !DC->isTranslationUnit())
+      while (!DC->isNamespace() && !DC->isTranslationUnitOrDeclareTarget())
         DC = getEffectiveParentContext(DC);
 
-    if (DC->isTranslationUnit() && D->getFormalLinkage() == InternalLinkage &&
+    if (DC->isTranslationUnitOrDeclareTarget() && D->getFormalLinkage() == InternalLinkage &&
         !isa<VarTemplateSpecializationDecl>(D) &&
         D->getIdentifier() != nullptr)
       return false;
   }
 
   return true;
 }
 
void MicrosoftCXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND,
   }
 }
 
 void MicrosoftCXXNameMangler::mangleNestedName(const NamedDecl *ND) {
   // <postfix> ::= <unqualified-name> [<postfix>]
   //           ::= <substitution> [<postfix>]
   const DeclContext *DC = getEffectiveDeclContext(ND);
 
-  while (!DC->isTranslationUnit()) {
+  while (!DC->isTranslationUnitOrDeclareTarget()) {
     if (isa<TagDecl>(ND) || isa<VarDecl>(ND)) {
       unsigned Disc;
       if (Context.getNextDiscriminator(ND, Disc)) {
         Out << '?';
         mangleNumber(Disc);
         Out << '?';
       }
     }

lib/Basic/OpenMPKinds.cpp

 #define OPENMP_TASKLOOP_SIMD_CLAUSE(Name)                                      \
   case OMPC_##Name:                                                            \
     return true;
 #include "clang/Basic/OpenMPKinds.def"
     default:
       break;
     }
     break;
+  // No clauses allowed for 'omp [end] declare target' constructs.
+  case OMPD_declare_target:
+  case OMPD_end_declare_target:
   case OMPD_unknown:
   case OMPD_threadprivate:
   case OMPD_section:
   case OMPD_master:
   case OMPD_critical:
   case OMPD_taskyield:
   case OMPD_barrier:
   case OMPD_taskwait:

lib/CodeGen/CGDecl.cpp

 #include "CGCleanup.h"
 #include "CGDebugInfo.h"
 #include "CGOpenCLRuntime.h"
 #include "CodeGenModule.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclObjC.h"
+#include "clang/AST/DeclOpenMP.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/CodeGen/CGFunctionInfo.h"
 #include "clang/Frontend/CodeGenOptions.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Type.h"
case Decl::UsingDirective: // using namespace X; [C++]
     return;
   case Decl::Var: {
     const VarDecl &VD = cast<VarDecl>(D);
     assert(VD.isLocalVarDecl() &&
            "Should not see file-scope variables inside a function!");
     return EmitVarDecl(VD);
   }
 
+  case Decl::OMPDeclareTarget:
+    return CGM.EmitOMPDeclareTarget(cast<OMPDeclareTargetDecl>(&D));
+
   case Decl::Typedef:      // typedef int X;
   case Decl::TypeAlias: {  // using X = int; [C++0x]
     const TypedefNameDecl &TD = cast<TypedefNameDecl>(D);
     QualType Ty = TD.getUnderlyingType();
 
     if (Ty->isVariablyModifiedType())
       EmitVariablyModifiedType(Ty);
   }
if (CGM.getCodeGenOpts().getDebugInfo()
           >= CodeGenOptions::LimitedDebugInfo) {
       DI->EmitDeclareOfArgVariable(&D, DeclPtr.getPointer(), ArgNo, Builder);
     }
   }
 
   if (D.hasAttr<AnnotateAttr>())
     EmitVarAnnotations(&D, DeclPtr.getPointer());
 }
+
+void CodeGenModule::EmitOMPDeclareTarget(const OMPDeclareTargetDecl *D) {
+    
+  for (DeclContext::decl_iterator I = D->decls_begin(), E = D->decls_end();
+  I != E; ++I) {
+    if (const VarDecl *VD = dyn_cast<VarDecl>(*I))
+      if (VD->getTemplateSpecializationKind() != TSK_ExplicitSpecialization &&
+        VD->getTemplateSpecializationKind() != TSK_Undeclared)
+        continue;
+
+    EmitTopLevelDecl(*I);
+  }
+
+
+}
 No newline at end of file

lib/CodeGen/CodeGenModule.h

SanitizerMetadata *getSanitizerMetadata() {
     return SanitizerMD.get();
   }
 
   void addDeferredVTable(const CXXRecordDecl *RD) {
     DeferredVTables.push_back(RD);
   }
 
   /// Emit code for a singal global function or var decl. Forward declarations
   /// are emitted lazily.
   void EmitGlobal(GlobalDecl D);
 
   bool TryEmitDefinitionAsAlias(GlobalDecl Alias, GlobalDecl Target,
                                 bool InEveryTU);
   bool TryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D);
 
   /// Set attributes for a global definition.
   void setFunctionDefinitionAttributes(const FunctionDecl *D,
                                        llvm::Function *F);
 
   llvm::GlobalValue *GetGlobalValue(StringRef Ref);
 
   /// Set attributes which are common to any form of a global definition (alias,
   /// Objective-C method, function, global variable).
   ///
   /// NOTE: This should only be called for definitions.
   void SetCommonAttributes(const Decl *D, llvm::GlobalValue *GV);
 
   /// Set attributes which must be preserved by an alias. This includes common
   /// attributes (i.e. it includes a call to SetCommonAttributes).
   ///
   /// NOTE: This should only be called for definitions.
   void setAliasAttributes(const Decl *D, llvm::GlobalValue *GV);
 
   void addReplacement(StringRef Name, llvm::Constant *C);
 
   void addGlobalValReplacement(llvm::GlobalValue *GV, llvm::Constant *C);
 
   /// \brief Emit a code for threadprivate directive.
   /// \param D Threadprivate declaration.
   void EmitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D);
 
+  /// \brief Emit declare target decls.
+  ///
+  void EmitOMPDeclareTarget(const OMPDeclareTargetDecl *D);
+
   /// Returns whether the given record is blacklisted from control flow
   /// integrity checks.
   bool IsCFIBlacklistedRecord(const CXXRecordDecl *RD);
 
   /// Emit bit set entries for the given vtable using the given layout if
   /// vptr CFI is enabled.
   void EmitVTableBitSetEntries(llvm::GlobalVariable *VTable,
                                const VTableLayout &VTLayout);

lib/CodeGen/CodeGenModule.cpp

case Decl::ClassTemplateSpecialization: {
     const auto *Spec = cast<ClassTemplateSpecializationDecl>(D);
     if (DebugInfo &&
         Spec->getSpecializationKind() == TSK_ExplicitInstantiationDefinition &&
         Spec->hasDefinition())
       DebugInfo->completeTemplateDefinition(*Spec);
     break;
   }
 
+  case Decl::OMPDeclareTarget:
+    EmitOMPDeclareTarget(cast<OMPDeclareTargetDecl>(D));
+    break;
+
   default:
     // Make sure we handled everything we should, every other kind is a
     // non-top-level decl.  FIXME: Would be nice to have an isTopLevelDeclKind
     // function. Need to recode Decl::Kind to do that easily.
     assert(isa<TypeDecl>(D) && "Unsupported decl kind");
     break;
   }
 }

lib/Parse/ParseDecl.cpp

while (!tryParseMisplacedModuleImport() && Tok.isNot(tok::r_brace) &&
 
     if (Tok.is(tok::annot_pragma_align)) {
       HandlePragmaAlign();
       continue;
     }
 
     if (Tok.is(tok::annot_pragma_openmp)) {
       // Result can be ignored, because it must be always empty.
-      auto Res = ParseOpenMPDeclarativeDirective();
+      auto Res = ParseOpenMPDeclarativeDirective(AS_public);
       assert(!Res);
       // Silence possible warnings.
       (void)Res;
       continue;
     }
     if (!Tok.is(tok::at)) {
       auto CFieldCallback = [&](ParsingFieldDeclarator &FD) {
         // Install the declarator into the current TagDecl.
         Decl *Field =
             Actions.ActOnField(getCurScope(), TagDecl,
                                FD.D.getDeclSpec().getSourceRange().getBegin(),

lib/Parse/ParseDeclCXX.cpp

if (Actions.ActOnAccessSpecifier(NewAS, ASLoc, EndLoc,
       // found another attribute than only annotations
       AccessAttrs.clear();
     }
 
     return DeclGroupPtrTy();
   }
 
   if (Tok.is(tok::annot_pragma_openmp))
-    return ParseOpenMPDeclarativeDirective();
+    return ParseOpenMPDeclarativeDirective(AS);
 
   // Parse all the comma separated declarators.
   return ParseCXXClassMemberDeclaration(AS, AccessAttrs.getList());
 }
 
 /// ParseCXXMemberSpecification - Parse the class definition.
 ///
 ///       member-specification:

lib/Parse/ParseOpenMP.cpp

 //===----------------------------------------------------------------------===//
 
 static OpenMPDirectiveKind ParseOpenMPDirectiveKind(Parser &P) {
   // Array of foldings: F[i][0] F[i][1] ===> F[i][2].
   // E.g.: OMPD_for OMPD_simd ===> OMPD_for_simd
   // TODO: add other combined directives in topological order.
   const OpenMPDirectiveKind F[][3] = {
       {OMPD_unknown /*cancellation*/, OMPD_unknown /*point*/,
-       OMPD_cancellation_point},
-      {OMPD_target, OMPD_unknown /*data*/, OMPD_target_data},
-      {OMPD_for, OMPD_simd, OMPD_for_simd},
-      {OMPD_parallel, OMPD_for, OMPD_parallel_for},
-      {OMPD_parallel_for, OMPD_simd, OMPD_parallel_for_simd},
-      {OMPD_parallel, OMPD_sections, OMPD_parallel_sections},
-      {OMPD_taskloop, OMPD_simd, OMPD_taskloop_simd}};
+       OMPD_cancellation_point}, //0
+    {OMPD_unknown /*declare*/, OMPD_target /*target*/,
+     OMPD_declare_target }, //1
+    {OMPD_unknown /*end*/, OMPD_unknown /*declare*/,
+     OMPD_end_declare_target }, //2
+      {OMPD_target, OMPD_unknown /*data*/, OMPD_target_data}, //3
+      {OMPD_for, OMPD_simd, OMPD_for_simd}, //4
+      {OMPD_parallel, OMPD_for, OMPD_parallel_for}, //5
+      {OMPD_parallel_for, OMPD_simd, OMPD_parallel_for_simd}, //6
+      {OMPD_parallel, OMPD_sections, OMPD_parallel_sections}, //7
+      {OMPD_taskloop, OMPD_simd, OMPD_taskloop_simd}}; //8
   auto Tok = P.getCurToken();
   auto DKind =
       Tok.isAnnotation()
           ? OMPD_unknown
           : getOpenMPDirectiveKind(P.getPreprocessor().getSpelling(Tok));
 
   bool TokenMatched = false;
   for (unsigned i = 0; i < llvm::array_lengthof(F); ++i) {
     if (!Tok.isAnnotation() && DKind == OMPD_unknown) {
       TokenMatched =
           (i == 0) &&
-          !P.getPreprocessor().getSpelling(Tok).compare("cancellation");
+           !P.getPreprocessor().getSpelling(Tok).compare("cancellation") ||
+          ((i == 1 || i == 3) &&
+           !P.getPreprocessor().getSpelling(Tok).compare("declare")) ||
+          ((i == 2) &&
+           !P.getPreprocessor().getSpelling(Tok).compare("end")) ||
+          ((i == 3) && 
+           !P.getPreprocessor().getSpelling(Tok).compare("target"));
     } else {
       TokenMatched = DKind == F[i][0] && DKind != OMPD_unknown;
     }
 
     if (TokenMatched) {
       Tok = P.getPreprocessor().LookAhead(0);
       auto TokenIsAnnotation = Tok.isAnnotation();
       auto SDKind =
           TokenIsAnnotation
               ? OMPD_unknown
               : getOpenMPDirectiveKind(P.getPreprocessor().getSpelling(Tok));
 
       if (!TokenIsAnnotation && SDKind == OMPD_unknown) {
         TokenMatched =
             ((i == 0) &&
              !P.getPreprocessor().getSpelling(Tok).compare("point")) ||
-            ((i == 1) && !P.getPreprocessor().getSpelling(Tok).compare("data"));
+            ((i == 2) &&
+             !P.getPreprocessor().getSpelling(Tok).compare("declare")) ||
+            ((i == 3) && 
+             !P.getPreprocessor().getSpelling(Tok).compare("data"));
       } else {
         TokenMatched = SDKind == F[i][1] && SDKind != OMPD_unknown;
       }
 
       if (TokenMatched) {
         P.ConsumeToken();
         DKind = F[i][2];
       }
     }
   }
   return DKind;
 }
 
 /// \brief Parsing of declarative OpenMP directives.
 ///
 ///       threadprivate-directive:
 ///         annot_pragma_openmp 'threadprivate' simple-variable-list
 ///
-Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirective() {
+Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirective(AccessSpecifier AS) {
   assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!");
   ParenBraceBracketBalancer BalancerRAIIObj(*this);
 
   SourceLocation Loc = ConsumeToken();
   SmallVector<Expr *, 5> Identifiers;
   auto DKind = ParseOpenMPDirectiveKind(*this);
 
   switch (DKind) {
   case OMPD_threadprivate:
     ConsumeToken();
     if (!ParseOpenMPSimpleVarList(OMPD_threadprivate, Identifiers, true)) {
       // The last seen token is annot_pragma_openmp_end - need to check for
       // extra tokens.
       if (Tok.isNot(tok::annot_pragma_openmp_end)) {
         Diag(Tok, diag::warn_omp_extra_tokens_at_eol)
             << getOpenMPDirectiveName(OMPD_threadprivate);
         SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
       }
       // Skip the last annot_pragma_openmp_end.
       ConsumeToken();
       return Actions.ActOnOpenMPThreadprivateDirective(Loc, Identifiers);
     }
     break;
+  case OMPD_declare_target: {
+    SourceLocation DTLoc = ConsumeAnyToken();
+    if (Tok.isNot(tok::annot_pragma_openmp_end)) {
+      Diag(Tok, diag::warn_omp_extra_tokens_at_eol)
+        << getOpenMPDirectiveName(OMPD_declare_target);
+      while (!SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch))
+        ;
+    }
+    // Skip the last annot_pragma_openmp_end.
+    ConsumeAnyToken();
+
+    ParseScope OMPDeclareTargetScope(this, Scope::DeclScope);
+    if (!Actions.ActOnStartOpenMPDeclareTargetDirective(getCurScope(), DTLoc))
+      return DeclGroupPtrTy();
+
+    DKind = ParseOpenMPDirectiveKind(*this);
+    while (DKind != OMPD_end_declare_target && DKind != OMPD_declare_target &&
+      Tok.isNot(tok::eof)) {
+      ParsedAttributesWithRange attrs(AttrFactory);
+      MaybeParseCXX11Attributes(attrs);
+      MaybeParseMicrosoftAttributes(attrs);
+      Actions.ActOnOpenMPDeclareTargetDecls(ParseExternalDeclaration(attrs));
+      if (Tok.isAnnotation() && Tok.is(tok::annot_pragma_openmp)) {
+        TentativeParsingAction TPA(*this);
+        ConsumeToken();
+        DKind = ParseOpenMPDirectiveKind(*this);
+        if (DKind != OMPD_end_declare_target) {
+          TPA.Revert();
+        }
+        else {
+          TPA.Commit();
+        }
+      }
+    }
+    if (DKind == OMPD_end_declare_target) {
+      // Skip the last annot_pragma_openmp_end.
+      ConsumeAnyToken();
+      ConsumeAnyToken();
+      if (Tok.isNot(tok::annot_pragma_openmp_end)) {
+        Diag(Tok, diag::warn_omp_extra_tokens_at_eol)
+          << getOpenMPDirectiveName(OMPD_end_declare_target);
+        while (!SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch))
+          ;
+      }
+      // Skip the last annot_pragma_openmp_end.
+      ConsumeAnyToken();
+      return Actions.ActOnFinishOpenMPDeclareTargetDirective();
+    }
+    Actions.ActOnOpenMPDeclareTargetDirectiveError();
+    Diag(Tok, diag::err_expected_end_declare_target);
+    Diag(DTLoc, diag::note_matching) << "'#pragma omp declare target'";
+    return DeclGroupPtrTy();
+  }
   case OMPD_unknown:
     Diag(Tok, diag::err_omp_unknown_directive);
     break;
   case OMPD_parallel:
   case OMPD_simd:
   case OMPD_task:
   case OMPD_taskyield:
   case OMPD_barrier:
Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirective(AccessSpecifier AS) {
   case OMPD_atomic:
   case OMPD_target:
   case OMPD_teams:
   case OMPD_cancellation_point:
   case OMPD_cancel:
   case OMPD_target_data:
   case OMPD_taskloop:
   case OMPD_taskloop_simd:
+  case OMPD_end_declare_target:
     Diag(Tok, diag::err_omp_unexpected_directive)
         << getOpenMPDirectiveName(DKind);
     break;
   }
-  SkipUntil(tok::annot_pragma_openmp_end);
+  while (!SkipUntil(tok::annot_pragma_openmp_end))
+    ;
   return DeclGroupPtrTy();
 }
 
 /// \brief Parsing of declarative or executable OpenMP directives.
 ///
 ///       threadprivate-directive:
 ///         annot_pragma_openmp 'threadprivate' simple-variable-list
 ///         annot_pragma_openmp_end
Directive = Actions.ActOnOpenMPExecutableDirective(
         DKind, DirName, CancelRegion, Clauses, AssociatedStmt.get(), Loc,
         EndLoc);
 
     // Exit scope.
     Actions.EndOpenMPDSABlock(Directive.get());
     OMPDirectiveScope.Exit();
     break;
   }
+  case OMPD_declare_target:
+  case OMPD_end_declare_target:
+    Diag(Tok, diag::err_omp_unexpected_directive)
+      << getOpenMPDirectiveName(DKind);
+    while (!SkipUntil(tok::annot_pragma_openmp_end))
+      ;
+    break;
   case OMPD_unknown:
-    Diag(Tok, diag::err_omp_unknown_directive);
-    SkipUntil(tok::annot_pragma_openmp_end);
-    break;
+    Diag(Tok, diag::err_omp_unknown_directive);
+    SkipUntil(tok::annot_pragma_openmp_end);
+    break;
   }
+
   return Directive;
 }
 
 /// \brief Parses list of simple variables for '#pragma omp threadprivate'
 /// directive.
 ///
 ///   simple-variable-list:
 ///         '(' id-expression {, id-expression} ')'

lib/Parse/Parser.cpp

case tok::annot_pragma_redefine_extname:
     return DeclGroupPtrTy();
   case tok::annot_pragma_fp_contract:
     HandlePragmaFPContract();
     return DeclGroupPtrTy();
   case tok::annot_pragma_opencl_extension:
     HandlePragmaOpenCLExtension();
     return DeclGroupPtrTy();
   case tok::annot_pragma_openmp:
-    return ParseOpenMPDeclarativeDirective();
+    return ParseOpenMPDeclarativeDirective(/*AS=*/AS_none);
   case tok::annot_pragma_ms_pointers_to_members:
     HandlePragmaMSPointersToMembers();
     return DeclGroupPtrTy();
   case tok::annot_pragma_ms_vtordisp:
     HandlePragmaMSVtorDisp();
     return DeclGroupPtrTy();
   case tok::annot_pragma_ms_pragma:
     HandlePragmaMSPragma();
if (DP) {
       Actions.MarkAsLateParsedTemplate(FnD, DP, Toks);
     }
     return DP;
   }
   else if (CurParsedObjCImpl && 
            !TemplateInfo.TemplateParams &&
            (Tok.is(tok::l_brace) || Tok.is(tok::kw_try) ||
             Tok.is(tok::colon)) && 
-      Actions.CurContext->isTranslationUnit()) {
+      Actions.CurContext->isTranslationUnitOrDeclareTarget()) {
     ParseScope BodyScope(this, Scope::FnScope|Scope::DeclScope);
     Scope *ParentScope = getCurScope()->getParent();
 
     D.setFunctionDefinitionKind(FDK_Definition);
     Decl *FuncDecl = Actions.HandleDeclarator(ParentScope, D,
                                               MultiTemplateParamsArg());
     D.complete(FuncDecl);
     D.getMutableDeclSpec().abort();

lib/Sema/SemaDecl.cpp

if (!D.getCXXScopeSpec().isSet()) {
     // the same name.
     if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
       /* Do nothing*/;
     else if (CurContext->isFunctionOrMethod() &&
              (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern ||
               R->isFunctionType())) {
       IsLinkageLookup = true;
       CreateBuiltins =
-          CurContext->getEnclosingNamespaceContext()->isTranslationUnit();
-    } else if (CurContext->getRedeclContext()->isTranslationUnit() &&
+          CurContext->getEnclosingNamespaceContext()->isTranslationUnitOrDeclareTarget();
+    } else if (CurContext->getRedeclContext()->isTranslationUnitOrDeclareTarget() &&
                D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
       CreateBuiltins = true;
 
     if (IsLinkageLookup)
       Previous.clear(LookupRedeclarationWithLinkage);
 
     LookupName(Previous, S, CreateBuiltins);
   } else { // Something like "int foo::x;"
if (New->getDeclName() && AddToScope &&
     // declaration of this entity. Qualified lookup for such an entity should
     // only find this declaration if there is no visible declaration of it.
     bool AddToContext = !D.isRedeclaration() || !New->isLocalExternDecl();
     PushOnScopeChains(New, S, AddToContext);
     if (!AddToContext)
       CurContext->addHiddenDecl(New);
   }
 
+  if (IsDeclContextInOpenMPTarget(CurContext)) {
+    CheckDeclIsAllowedInOpenMPTarget(0, New);
+  }
+
   return New;
 }
 
 /// Helper method to turn variable array types into constant array
 /// types in certain situations which would otherwise be errors (for
 /// GCC compatibility).
 static QualType TryToFixInvalidVariablyModifiedType(QualType T,
                                                     ASTContext &Context,

 
 /// \brief Register the given locally-scoped extern "C" declaration so
 /// that it can be found later for redeclarations. We include any extern "C"
 /// declaration that is not visible in the translation unit here, not just
 /// function-scope declarations.
 void
 Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S) {
   if (!getLangOpts().CPlusPlus &&
-      ND->getLexicalDeclContext()->getRedeclContext()->isTranslationUnit())
+      ND->getLexicalDeclContext()->getRedeclContext()->isTranslationUnitOrDeclareTarget())
     // Don't need to track declarations in the TU in C.
     return;
 
   // Note that we have a locally-scoped external with this name.
   Context.getExternCContextDecl()->makeDeclVisibleInContext(ND);
 }
 
 NamedDecl *Sema::findLocallyScopedExternCDecl(DeclarationName Name) {
Sema::ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *NewTD,
   if (!Previous.empty()) {
     Redeclaration = true;
     MergeTypedefNameDecl(S, NewTD, Previous);
   }
 
   // If this is the C FILE type, notify the AST context.
   if (IdentifierInfo *II = NewTD->getIdentifier())
     if (!NewTD->isInvalidDecl() &&
-        NewTD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
+        NewTD->getDeclContext()->getRedeclContext()->isTranslationUnitOrDeclareTarget()) {
       if (II->isStr("FILE"))
         Context.setFILEDecl(NewTD);
       else if (II->isStr("jmp_buf"))
         Context.setjmp_bufDecl(NewTD);
       else if (II->isStr("sigjmp_buf"))
         Context.setsigjmp_bufDecl(NewTD);
       else if (II->isStr("ucontext_t"))
         Context.setucontext_tDecl(NewTD);

 ///   the same name as an entity in global scope.
 template<typename T>
 static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND,
                                                   LookupResult &Previous) {
   if (!S.getLangOpts().CPlusPlus) {
     // In C, when declaring a global variable, look for a corresponding 'extern'
     // variable declared in function scope. We don't need this in C++, because
     // we find local extern decls in the surrounding file-scope DeclContext.
-    if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
+    if (ND->getDeclContext()->getRedeclContext()->isTranslationUnitOrDeclareTarget()) {
       if (NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName())) {
         Previous.clear();
         Previous.addDecl(Prev);
         return true;
       }
     }
     return false;
   }
 
   // A declaration in the translation unit can conflict with an extern "C"
   // declaration.
-  if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit())
+  if (ND->getDeclContext()->getRedeclContext()->isTranslationUnitOrDeclareTarget())
     return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/true, Previous);
 
   // An extern "C" declaration can conflict with a declaration in the
   // translation unit or can be a redeclaration of an extern "C" declaration
   // in another scope.
   if (isIncompleteDeclExternC(S,ND))
     return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/false, Previous);
 
for (auto Param : NewFD->params())
       checkIsValidOpenCLKernelParameter(*this, D, Param, ValidTypes);
   }
 
   MarkUnusedFileScopedDecl(NewFD);
 
   if (getLangOpts().CUDA)
     if (IdentifierInfo *II = NewFD->getIdentifier())
       if (!NewFD->isInvalidDecl() &&
-          NewFD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
+          NewFD->getDeclContext()->getRedeclContext()->isTranslationUnitOrDeclareTarget()) {
         if (II->isStr("cudaConfigureCall")) {
           if (!R->getAs<FunctionType>()->getReturnType()->isScalarType())
             Diag(NewFD->getLocation(), diag::err_config_scalar_return);
 
           Context.setcudaConfigureCallDecl(NewFD);
         }
       }
   
if (getLangOpts().CUDA && getLangOpts().CUDATargetOverloads &&
         FD->addAttr(CUDAHostAttr::CreateImplicit(Context, FD->getLocation()));
     }
   }
 
   IdentifierInfo *Name = FD->getIdentifier();
   if (!Name)
     return;
   if ((!getLangOpts().CPlusPlus &&
-       FD->getDeclContext()->isTranslationUnit()) ||
+       FD->getDeclContext()->isTranslationUnitOrDeclareTarget()) ||
       (isa<LinkageSpecDecl>(FD->getDeclContext()) &&
        cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() ==
        LinkageSpecDecl::lang_c)) {
     // Okay: this could be a libc/libm/Objective-C function we know
     // about.
   } else
     return;
 

 ///   }
 static FixItHint createFriendTagNNSFixIt(Sema &SemaRef, NamedDecl *ND, Scope *S,
                                          SourceLocation NameLoc) {
   // While the decl is in a namespace, do repeated lookup of that name and see
   // if we get the same namespace back.  If we do not, continue until
   // translation unit scope, at which point we have a fully qualified NNS.
   SmallVector<IdentifierInfo *, 4> Namespaces;
   DeclContext *DC = ND->getDeclContext()->getRedeclContext();
-  for (; !DC->isTranslationUnit(); DC = DC->getParent()) {
+  for (; !DC->isTranslationUnitOrDeclareTarget(); DC = DC->getParent()) {
     // This tag should be declared in a namespace, which can only be enclosed by
     // other namespaces.  Bail if there's an anonymous namespace in the chain.
     NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(DC);
     if (!Namespace || Namespace->isAnonymousNamespace())
       return FixItHint();
     IdentifierInfo *II = Namespace->getIdentifier();
     Namespaces.push_back(II);
     NamedDecl *Lookup = SemaRef.LookupSingleName(
         S, II, NameLoc, Sema::LookupNestedNameSpecifierName);
     if (Lookup == Namespace)
       break;
   }
 
   // Once we have all the namespaces, reverse them to go outermost first, and
   // build an NNS.
   SmallString<64> Insertion;
   llvm::raw_svector_ostream OS(Insertion);
-  if (DC->isTranslationUnit())
+  if (DC->isTranslationUnitOrDeclareTarget())
     OS << "::";
   std::reverse(Namespaces.begin(), Namespaces.end());
   for (auto *II : Namespaces)
     OS << II->getName() << "::";
   return FixItHint::CreateInsertion(NameLoc, Insertion);
 }
 
 /// \brief Determine whether a tag originally declared in context \p OldDC can
CreateNewDecl:
 
   } else {
     CurContext->addDecl(New);
   }
 
   // If this is the C FILE type, notify the AST context.
   if (IdentifierInfo *II = New->getIdentifier())
     if (!New->isInvalidDecl() &&
-        New->getDeclContext()->getRedeclContext()->isTranslationUnit() &&
+        New->getDeclContext()->getRedeclContext()->isTranslationUnitOrDeclareTarget() &&
         II->isStr("FILE"))
       Context.setFILEDecl(New);
 
   if (PrevDecl)
     mergeDeclAttributes(New, PrevDecl);
 
   // If there's a #pragma GCC visibility in scope, set the visibility of this
   // record.

lib/Sema/SemaExpr.cpp

 /// (C++ [basic.def.odr]p2, C99 6.9p3).  Note that this should not be
 /// used directly for normal expressions referring to VarDecl.
 void Sema::MarkVariableReferenced(SourceLocation Loc, VarDecl *Var) {
   DoMarkVarDeclReferenced(*this, Loc, Var, nullptr);
 }
 
 static void MarkExprReferenced(Sema &SemaRef, SourceLocation Loc,
                                Decl *D, Expr *E, bool OdrUse) {
+  if (SemaRef.IsDeclContextInOpenMPTarget(SemaRef.CurContext)) 
+  SemaRef.CheckDeclIsAllowedInOpenMPTarget(E, D);
+    
   if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
     DoMarkVarDeclReferenced(SemaRef, Loc, Var, E);
     return;
   }
 
   SemaRef.MarkAnyDeclReferenced(Loc, D, OdrUse);
 
   // If this is a call to a method via a cast, also mark the method in the

lib/Sema/SemaLookup.cpp

for (DeclContext::lookup_iterator I = DR.begin(), E = DR.end(); I != E;
        ++I) {
     NamedDecl *D = *I;
     if ((D = R.getAcceptableDecl(D))) {
       R.addDecl(D);
       Found = true;
     }
   }
 
-  if (!Found && DC->isTranslationUnit() && LookupBuiltin(S, R))
+  if (!Found && DC->isTranslationUnitOrDeclareTarget() && LookupBuiltin(S, R))
     return true;
 
   if (R.getLookupName().getNameKind()
         != DeclarationName::CXXConversionFunctionName ||
       R.getLookupName().getCXXNameType()->isDependentType() ||
       !isa<CXXRecordDecl>(DC))
     return Found;
 

lib/Sema/SemaOpenMP.cpp

private:
   OpenMPClauseKind ClauseKindMode;
   Sema &SemaRef;
   bool ForceCapturing;
 
   typedef SmallVector<SharingMapTy, 8>::reverse_iterator reverse_iterator;
 
   DSAVarData getDSA(StackTy::reverse_iterator Iter, VarDecl *D);
 
+  typedef llvm::DenseSet<Decl *> DeclaredTargetDeclsTy;
+
+  DeclaredTargetDeclsTy DeclaredTargetDecls;
+
+  OpenMPClauseKind getDSA(StackTy::reverse_iterator Iter, VarDecl *D,
+    OpenMPDirectiveKind &Kind, DeclRefExpr *&E);
+
   /// \brief Checks if the variable is a local for OpenMP region.
   bool isOpenMPLocal(VarDecl *D, StackTy::reverse_iterator Iter);
 
 public:
   explicit DSAStackTy(Sema &S)
       : Stack(1), ClauseKindMode(OMPC_unknown), SemaRef(S),
         ForceCapturing(false) {}
 
void push(OpenMPDirectiveKind DKind, const DeclarationNameInfo &DirName,
     Stack.back().DefaultAttrLoc = Loc;
   }
 
   void pop() {
     assert(Stack.size() > 1 && "Data-sharing attributes stack is empty!");
     Stack.pop_back();
   }
 
+  bool IsThreadprivate(VarDecl *D, DeclRefExpr *&E);
+
   /// \brief If 'aligned' declaration for given variable \a D was not seen yet,
   /// add it and return NULL; otherwise return previous occurrence's expression
   /// for diagnostics.
   DeclRefExpr *addUniqueAligned(VarDecl *D, DeclRefExpr *NewDE);
 
   /// \brief Register specified variable as loop control variable.
   void addLoopControlVariable(VarDecl *D);
   /// \brief Check if the specified variable is a loop control variable for
if (Stack.size() > 2)
       Stack[Stack.size() - 2].CancelRegion =
           Stack[Stack.size() - 2].CancelRegion || Cancel;
   }
   /// \brief Return true if current region has inner cancel construct.
   bool isCancelRegion() const {
     return Stack.back().CancelRegion;
   }
 
+  void addDeclareTargetDecl(Decl *D) { DeclaredTargetDecls.insert(D); }
+
+  bool isDeclareTargetDecl(Decl *D) { return DeclaredTargetDecls.count(D); }
+
   /// \brief Set collapse value for the region.
   void setCollapseNumber(unsigned Val) { Stack.back().CollapseNumber = Val; }
   /// \brief Return collapse value for region.
   unsigned getCollapseNumber() const {
     return Stack.back().CollapseNumber;
   }
 
   /// \brief Marks current target region as one with closely nested teams
static VarDecl *buildVarDecl(Sema &SemaRef, SourceLocation Loc, QualType Type,
   return Decl;
 }
 
 static DeclRefExpr *buildDeclRefExpr(Sema &S, VarDecl *D, QualType Ty,
                                      SourceLocation Loc,
                                      bool RefersToCapture = false) {
   D->setReferenced();
   D->markUsed(S.Context);
-  return DeclRefExpr::Create(S.getASTContext(), NestedNameSpecifierLoc(),
+  DeclRefExpr *E;
+
+  E = DeclRefExpr::Create(S.getASTContext(), NestedNameSpecifierLoc(),
                              SourceLocation(), D, RefersToCapture, Loc, Ty,
                              VK_LValue);
+
+  if (S.IsDeclContextInOpenMPTarget(S.CurContext)) {
+    S.CheckDeclIsAllowedInOpenMPTarget(E, E->getDecl());
+  }
+  return E;
+}
+
+bool DSAStackTy::IsThreadprivate(VarDecl *D, DeclRefExpr *&E) {
+  E = 0;
+  if (D->getTLSKind() != VarDecl::TLS_None)
+    return true;
+  if (Stack[0].SharingMap.count(D)) {
+    E = Stack[0].SharingMap[D].RefExpr;
+    return true;
+  }
+  return false;
 }
 
 DSAStackTy::DSAVarData DSAStackTy::getTopDSA(VarDecl *D, bool FromParent) {
   D = D->getCanonicalDecl();
   DSAVarData DVar;
 
   // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
   // in a Construct, C/C++, predetermined, p.1]
if (I->CurScope == S)
       return I->Directive;
   return OMPD_unknown;
 }
 
 void Sema::InitDataSharingAttributesStack() {
   VarDataSharingAttributesStack = new DSAStackTy(*this);
 }
 
+bool Sema::IsDeclContextInOpenMPTarget(DeclContext *DC) {
+  while (DC && !isa<OMPDeclareTargetDecl>(DC)) {
+    DC = DC->getParent();
+  }
+  return DC != 0;
+}
+
 #define DSAStack static_cast<DSAStackTy *>(VarDataSharingAttributesStack)
 
 bool Sema::IsOpenMPCapturedByRef(VarDecl *VD,
                                  const CapturedRegionScopeInfo *RSI) {
   assert(LangOpts.OpenMP && "OpenMP is not allowed");
 
   auto &Ctx = getASTContext();
   bool IsByRef = true;
if (!VD->hasGlobalStorage()) {
     return ExprError();
   }
 
   VarDecl *CanonicalVD = VD->getCanonicalDecl();
   NamedDecl *ND = cast<NamedDecl>(CanonicalVD);
   // OpenMP [2.9.2, Restrictions, C/C++, p.2]
   //   A threadprivate directive for file-scope variables must appear outside
   //   any definition or declaration.
-  if (CanonicalVD->getDeclContext()->isTranslationUnit() &&
-      !getCurLexicalContext()->isTranslationUnit()) {
+
+  if ((!getCurLexicalContext()->isFileContext() ||
+      !VD->getDeclContext()->isFileContext()) &&
+      !isDeclInScope(ND, getCurLexicalContext(), getCurScope())) {
     Diag(Id.getLoc(), diag::err_omp_var_scope)
         << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
     bool IsDecl =
         VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
     Diag(VD->getLocation(),
          IsDecl ? diag::note_previous_decl : diag::note_defined_here)
         << VD;
     return ExprError();
Diag(VD->getLocation(),
          IsDecl ? diag::note_previous_decl : diag::note_defined_here)
         << VD;
     return ExprError();
   }
 
   // OpenMP [2.9.2, Restrictions, C/C++, p.2-6]
   //   A threadprivate directive must lexically precede all references to any
   //   of the variables in its list.
   if (VD->isUsed() && !DSAStack->isThreadPrivate(VD)) {
     Diag(Id.getLoc(), diag::err_omp_var_used)
         << getOpenMPDirectiveName(OMPD_threadprivate) << VD;
     return ExprError();
   }
 
   QualType ExprType = VD->getType().getNonReferenceType();
   ExprResult DE = buildDeclRefExpr(*this, VD, ExprType, Id.getLoc());
   return DE;
 }
Sema::CheckOMPThreadPrivateDecl(SourceLocation Loc, ArrayRef<Expr *> VarList) {
   if (!Vars.empty()) {
     D = OMPThreadPrivateDecl::Create(Context, getCurLexicalContext(), Loc,
                                      Vars);
     D->setAccess(AS_public);
   }
   return D;
 }
 
+bool Sema::ActOnStartOpenMPDeclareTargetDirective(Scope *S,
+  SourceLocation Loc) {
+  if (CurContext && !CurContext->isFileContext() &&
+    !CurContext->isExternCContext() && !CurContext->isExternCXXContext()) {
+    Diag(Loc, diag::err_omp_region_not_file_context);
+    return false;
+  }
+  OMPDeclareTargetDecl *DT =
+    OMPDeclareTargetDecl::Create(Context, CurContext, Loc);
+  DT->setAccess(AS_public);
+  CurContext->addDecl(DT);
+  if (CurScope)
+    PushDeclContext(S, DT);
+  else
+    CurContext = DT;
+  return true;
+}
+
+void Sema::ActOnOpenMPDeclareTargetDecls(Sema::DeclGroupPtrTy Decls) {
+  if (!Decls)
+    return;
+  DeclGroupRef DGR = Decls.get();
+  if (DGR.isNull())
+    return;
+  for (DeclGroupRef::iterator I = DGR.begin(), E = DGR.end(); I != E; ++I) {
+    if (*I)
+      DSAStack->addDeclareTargetDecl(*I);
+  }
+}
+
+Sema::DeclGroupPtrTy Sema::ActOnFinishOpenMPDeclareTargetDirective() {
+  if (CurContext && isa<OMPDeclareTargetDecl>(CurContext)) {
+    OMPDeclareTargetDecl *DT = cast<OMPDeclareTargetDecl>(CurContext);
+    PopDeclContext();
+    return DeclGroupPtrTy::make(DeclGroupRef(DT));
+  }
+  return DeclGroupPtrTy();
+}
+
+void Sema::ActOnOpenMPDeclareTargetDirectiveError() {
+  if (CurContext && isa<OMPDeclareTargetDecl>(CurContext)) {
+    PopDeclContext();
+  }
+}
+
+static bool IsCXXRecordForMappable(Sema &SemaRef, SourceLocation Loc,
+                                   DSAStackTy *Stack, CXXRecordDecl *RD) {
+  if (!RD || RD->isInvalidDecl())
+    return true;
+
+  auto QTy = SemaRef.Context.getRecordType(RD);
+  if (RD->isDynamicClass()) {
+    SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy;
+    SemaRef.Diag(RD->getLocation(), diag::note_omp_polymorphic_in_target);
+    return false;
+  }
+  auto *DC = RD;
+  bool IsCorrect = true;
+  for (auto *I : DC->decls()) {
+    if (I) {
+      if (auto *MD = dyn_cast<CXXMethodDecl>(I)) {
+        if (MD->isStatic()) {
+          SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy;
+          SemaRef.Diag(MD->getLocation(),
+                       diag::note_omp_static_member_in_target);
+          IsCorrect = false;
+        }
+      } else if (auto *VD = dyn_cast<VarDecl>(I)) {
+        if (VD->isStaticDataMember()) {
+          SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy;
+          SemaRef.Diag(VD->getLocation(),
+                       diag::note_omp_static_member_in_target);
+          IsCorrect = false;
+        }
+      }
+    }
+  }
+
+  for (auto &I : RD->bases()) {
+    if (!IsCXXRecordForMappable(SemaRef, I.getLocStart(), Stack,
+                                I.getType()->getAsCXXRecordDecl()))
+      IsCorrect = false;
+  }
+  return IsCorrect;
+}
+
+static void CheckDeclInTargetContext(SourceLocation SL, SourceRange SR,
+  Sema &SemaRef, DSAStackTy *Stack,
+  Decl *D) {
+  if (!D)
+    return;
+  Decl *LD = 0;
+  if (isa<TagDecl>(D)) {
+    LD = cast<TagDecl>(D)->getDefinition();
+  }
+  else if (isa<VarDecl>(D)) {
+    LD = cast<VarDecl>(D)->getDefinition();
+
+    // If this is an implicit variable that is legal and we do not need to do
+    // anything
+    if (cast<VarDecl>(D)->isImplicit()) {
+      Stack->addDeclareTargetDecl(D);
+      return;
+    }
+
+  }
+  else if (isa<FunctionDecl>(D)) {
+    const FunctionDecl *FD = 0;
+    if (cast<FunctionDecl>(D)->hasBody(FD))
+      LD = const_cast<FunctionDecl *>(FD);
+
+    // If the definition is associated with the current declaration in the
+    // target region (it can be e.g. a lambda) that is legal and we do not need
+    // to do anything else
+    if (LD == D) {
+      Stack->addDeclareTargetDecl(D);
+      return;
+    }
+  }
+  if (!LD)
+    LD = D;
+  if (LD) {
+    if (!Stack->isDeclareTargetDecl(LD)) {
+      // Outlined declaration is not declared target.
+      if (LD->isOutOfLine()) {
+        SemaRef.Diag(LD->getLocation(), diag::warn_omp_not_in_target_context);
+        SemaRef.Diag(SL, diag::note_used_here) << SR;
+      }
+      else {
+        DeclContext *DC = LD->getDeclContext();
+        while (DC) {
+          if (isa<OMPDeclareTargetDecl>(DC))
+            break;
+          DC = DC->getParent();
+        }
+        // Is not declared in target context.
+        if (!DC) {
+          SemaRef.Diag(LD->getLocation(), diag::warn_omp_not_in_target_context);
+          SemaRef.Diag(SL, diag::note_used_here) << SR;
+        }
+      }
+    }
+    // Mark decl as declared to prevent further diagnostic.
+    if (isa<VarDecl>(LD) || isa<FunctionDecl>(LD))
+      Stack->addDeclareTargetDecl(LD);
+  }
+}
+
+static bool CheckTypeMappable(SourceLocation SL, SourceRange SR, Sema &SemaRef,
+  DSAStackTy *Stack, QualType QTy) {
+  NamedDecl *ND;
+  if (QTy->isIncompleteType(&ND)) {
+      SemaRef.Diag(SL, diag::err_incomplete_type) << QTy << SR;
+      return false;
+  } else if (CXXRecordDecl *RD = dyn_cast_or_null<CXXRecordDecl>(ND)) {
+    if (!RD->isInvalidDecl() &&
+        !IsCXXRecordForMappable(SemaRef, SL, Stack, RD))
+      return false;
+  }
+  return true;
+}
+
+static bool CheckValueDeclInTarget(SourceLocation SL, SourceRange SR,
+  Sema &SemaRef, DSAStackTy *Stack,
+  ValueDecl *VD) {
+  if (Stack->isDeclareTargetDecl(VD))
+    return true;
+  if (!CheckTypeMappable(SL, SR, SemaRef, Stack, VD->getType())) {
+    return false;
+  }
+  return true;
+}
+
+void Sema::CheckDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D) {
+  if (!D || D->isInvalidDecl())
+    return;
+  SourceRange SR = E ? E->getSourceRange() : D->getSourceRange();
+  SourceLocation SL = E ? E->getLocStart() : D->getLocation();
+  if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
+    DeclRefExpr *DRE;
+    if (DSAStack->IsThreadprivate(VD, DRE)) {
+      SourceLocation Loc = DRE ? DRE->getLocation() : VD->getLocation();
+      Diag(Loc, diag::err_omp_threadprivate_in_target);
+      Diag(SL, diag::note_used_here) << SR;
+      D->setInvalidDecl();
+      return;
+    }
+  }
+  if (ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
+    if (!CheckValueDeclInTarget(SL, SR, *this, DSAStack, VD)) {
+      VD->setInvalidDecl();
+      return;
+    }
+  }
+  if (!E) {
+    // Checking declaration.
+    if (isa<VarDecl>(D) || isa<FunctionDecl>(D))
+      DSAStack->addDeclareTargetDecl(D);
+    return;
+  }
+  CheckDeclInTargetContext(E->getExprLoc(), E->getSourceRange(), *this,
+    DSAStack, D);
+}
+
 static void ReportOriginalDSA(Sema &SemaRef, DSAStackTy *Stack,
                               const VarDecl *VD, DSAStackTy::DSAVarData DVar,
                               bool IsLoopIterVar = false) {
   if (DVar.RefExpr) {
     SemaRef.Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_explicit_dsa)
         << getOpenMPClauseName(DVar.CKind);
     return;
   }
OMPClause *Sema::ActOnOpenMPDeviceClause(Expr *Device, SourceLocation StartLoc,
   // The device expression must evaluate to a non-negative integer value.
   if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_device,
                                  /*StrictlyPositive=*/false))
     return nullptr;
 
   return new (Context) OMPDeviceClause(ValExpr, StartLoc, LParenLoc, EndLoc);
 }
 
-static bool IsCXXRecordForMappable(Sema &SemaRef, SourceLocation Loc,
-                                   DSAStackTy *Stack, CXXRecordDecl *RD) {
-  if (!RD || RD->isInvalidDecl())
-    return true;
-
-  auto QTy = SemaRef.Context.getRecordType(RD);
-  if (RD->isDynamicClass()) {
-    SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy;
-    SemaRef.Diag(RD->getLocation(), diag::note_omp_polymorphic_in_target);
-    return false;
-  }
-  auto *DC = RD;
-  bool IsCorrect = true;
-  for (auto *I : DC->decls()) {
-    if (I) {
-      if (auto *MD = dyn_cast<CXXMethodDecl>(I)) {
-        if (MD->isStatic()) {
-          SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy;
-          SemaRef.Diag(MD->getLocation(),
-                       diag::note_omp_static_member_in_target);
-          IsCorrect = false;
-        }
-      } else if (auto *VD = dyn_cast<VarDecl>(I)) {
-        if (VD->isStaticDataMember()) {
-          SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy;
-          SemaRef.Diag(VD->getLocation(),
-                       diag::note_omp_static_member_in_target);
-          IsCorrect = false;
-        }
-      }
-    }
-  }
-
-  for (auto &I : RD->bases()) {
-    if (!IsCXXRecordForMappable(SemaRef, I.getLocStart(), Stack,
-                                I.getType()->getAsCXXRecordDecl()))
-      IsCorrect = false;
-  }
-  return IsCorrect;
-}
-
-static bool CheckTypeMappable(SourceLocation SL, SourceRange SR, Sema &SemaRef,
-                              DSAStackTy *Stack, QualType QTy) {
-  NamedDecl *ND;
-  if (QTy->isIncompleteType(&ND)) {
-    SemaRef.Diag(SL, diag::err_incomplete_type) << QTy << SR;
-    return false;
-  } else if (CXXRecordDecl *RD = dyn_cast_or_null<CXXRecordDecl>(ND)) {
-    if (!RD->isInvalidDecl() &&
-        !IsCXXRecordForMappable(SemaRef, SL, Stack, RD))
-      return false;
-  }
-  return true;
-}
-
 OMPClause *Sema::ActOnOpenMPMapClause(
     OpenMPMapClauseKind MapTypeModifier, OpenMPMapClauseKind MapType,
     SourceLocation MapLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
     SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc) {
   SmallVector<Expr *, 4> Vars;
 
   for (auto &RE : VarList) {
     assert(RE && "Null expr in omp map");

lib/Sema/SemaTemplateInstantiate.cpp

if (!Ctx) {
     }
 
     // If we have a template template parameter with translation unit context,
     // then we're performing substitution into a default template argument of
     // this template template parameter before we've constructed the template
     // that will own this template template parameter. In this case, we
     // use empty template parameter lists for all of the outer templates
     // to avoid performing any substitutions.
-    if (Ctx->isTranslationUnit()) {
+    if (Ctx->isTranslationUnitOrDeclareTarget()) {
       if (TemplateTemplateParmDecl *TTP 
                                       = dyn_cast<TemplateTemplateParmDecl>(D)) {
         for (unsigned I = 0, N = TTP->getDepth() + 1; I != N; ++I)
           Result.addOuterTemplateArguments(None);
         return Result;
       }
     }
   }

lib/Sema/SemaTemplateInstantiateDecl.cpp

OMPThreadPrivateDecl *TD =
     SemaRef.CheckOMPThreadPrivateDecl(D->getLocation(), Vars);
 
   TD->setAccess(AS_public);
   Owner->addDecl(TD);
 
   return TD;
 }
 
+Decl *
+TemplateDeclInstantiator::VisitOMPDeclareTargetDecl(OMPDeclareTargetDecl *D) {
+  llvm_unreachable("OpenMP declare target cannot be instantiated");
+}
+
 Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D) {
   return VisitFunctionDecl(D, nullptr);
 }
 
 Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D) {
   return VisitCXXMethodDecl(D, nullptr);
 }
 

lib/Serialization/ASTCommon.h

enum DeclUpdateKind {
   UPD_CXX_INSTANTIATED_CLASS_DEFINITION,
   UPD_CXX_RESOLVED_DTOR_DELETE,
   UPD_CXX_RESOLVED_EXCEPTION_SPEC,
   UPD_CXX_DEDUCED_RETURN_TYPE,
   UPD_DECL_MARKED_USED,
   UPD_MANGLING_NUMBER,
   UPD_STATIC_LOCAL_NUMBER,
   UPD_DECL_MARKED_OPENMP_THREADPRIVATE,
+  UPD_DECL_MARKED_OPENMP_DECLARETARGET,
   UPD_DECL_EXPORTED,
   UPD_ADDED_ATTR_TO_RECORD
 };
 
 TypeIdx TypeIdxFromBuiltin(const BuiltinType *BT);
 
 template <typename IdxForTypeTy>
 TypeID MakeTypeID(ASTContext &Context, QualType T, IdxForTypeTy IdxForType) {

lib/Serialization/ASTCommon.cpp

bool serialization::isRedeclarableDeclKind(unsigned Kind) {
   case Decl::Friend:
   case Decl::FriendTemplate:
   case Decl::StaticAssert:
   case Decl::Block:
   case Decl::Captured:
   case Decl::ClassScopeFunctionSpecialization:
   case Decl::Import:
   case Decl::OMPThreadPrivate:
+  case Decl::OMPDeclareTarget:
   case Decl::BuiltinTemplate:
     return false;
 
   // These indirectly derive from Redeclarable<T> but are not actually
   // redeclarable.
   case Decl::ImplicitParam:
   case Decl::ParmVar:
   case Decl::ObjCTypeParam:

lib/Serialization/ASTReaderDecl.cpp

public:
     void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
     void VisitObjCImplDecl(ObjCImplDecl *D);
     void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
     void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
     void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
     void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
     void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
     void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
+    void VisitOMPDeclareTargetDecl(OMPDeclareTargetDecl *D);
 
     /// We've merged the definition \p MergedDef into the existing definition
     /// \p Def. Ensure that \p Def is made visible whenever \p MergedDef is made
     /// visible.
     void mergeDefinitionVisibility(NamedDecl *Def, NamedDecl *MergedDef) {
       if (Def->isHidden()) {
         // If MergedDef is visible or becomes visible, make the definition visible.
         if (!MergedDef->isHidden())
void ASTDeclReader::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
   SmallVector<Expr *, 16> Vars;
   Vars.reserve(NumVars);
   for (unsigned i = 0; i != NumVars; ++i) {
     Vars.push_back(Reader.ReadExpr(F));
   }
   D->setVars(Vars);
 }
 
+void ASTDeclReader::VisitOMPDeclareTargetDecl(OMPDeclareTargetDecl *D) {
+  VisitDecl(D);
+}
+
 //===----------------------------------------------------------------------===//
 // Attribute Reading
 //===----------------------------------------------------------------------===//
 
 /// \brief Reads attributes from the current stream position.
 void ASTReader::ReadAttributes(ModuleFile &F, AttrVec &Attrs,
                                const RecordData &Record, unsigned &Idx) {
   for (unsigned i = 0, e = Record[Idx++]; i != e; ++i) {

 static bool isConsumerInterestedIn(Decl *D, bool HasBody) {
   // An ObjCMethodDecl is never considered as "interesting" because its
   // implementation container always is.
 
   if (isa<FileScopeAsmDecl>(D) || 
       isa<ObjCProtocolDecl>(D) || 
       isa<ObjCImplDecl>(D) ||
       isa<ImportDecl>(D) ||
-      isa<OMPThreadPrivateDecl>(D))
+      isa<OMPThreadPrivateDecl>(D) ||
+      isa<OMPDeclareTargetDecl>(D) )
     return true;
   if (VarDecl *Var = dyn_cast<VarDecl>(D))
     return Var->isFileVarDecl() &&
            Var->isThisDeclarationADefinition() == VarDecl::Definition;
   if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D))
     return Func->doesThisDeclarationHaveABody() || HasBody;
   
   return false;
ASTDeclReader::FindExistingResult::~FindExistingResult() {
   if (!AddResult || Existing)
     return;
 
   DeclarationName Name = New->getDeclName();
   DeclContext *DC = New->getDeclContext()->getRedeclContext();
   if (needsAnonymousDeclarationNumber(New)) {
     setAnonymousDeclForMerging(Reader, New->getLexicalDeclContext(),
                                AnonymousDeclNumber, New);
-  } else if (DC->isTranslationUnit() && Reader.SemaObj &&
+  } else if (DC->isTranslationUnitOrDeclareTarget() && Reader.SemaObj &&
              !Reader.getContext().getLangOpts().CPlusPlus) {
     if (Reader.SemaObj->IdResolver.tryAddTopLevelDecl(New, Name))
       Reader.PendingFakeLookupResults[Name.getAsIdentifierInfo()]
             .push_back(New);
   } else if (DeclContext *MergeDC = getPrimaryContextForMerging(Reader, DC)) {
     // Add the declaration to its redeclaration context so later merging
     // lookups will find it.
     MergeDC->makeDeclVisibleInContextImpl(New, /*Internal*/true);
ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {
   if (needsAnonymousDeclarationNumber(D)) {
     // This is an anonymous declaration that we may need to merge. Look it up
     // in its context by number.
     if (auto *Existing = getAnonymousDeclForMerging(
             Reader, D->getLexicalDeclContext(), AnonymousDeclNumber))
       if (isSameEntity(Existing, D))
         return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
                                   TypedefNameForLinkage);
-  } else if (DC->isTranslationUnit() && Reader.SemaObj &&
+  } else if (DC->isTranslationUnitOrDeclareTarget() && Reader.SemaObj &&
              !Reader.getContext().getLangOpts().CPlusPlus) {
     IdentifierResolver &IdResolver = Reader.SemaObj->IdResolver;
 
     // Temporarily consider the identifier to be up-to-date. We don't want to
     // cause additional lookups here.
     class UpToDateIdentifierRAII {
       IdentifierInfo *II;
       bool WasOutToDate;
Decl *ASTReader::ReadDeclRecord(DeclID ID) {
   case DECL_IMPORT:
     // Note: last entry of the ImportDecl record is the number of stored source 
     // locations.
     D = ImportDecl::CreateDeserialized(Context, ID, Record.back());
     break;
   case DECL_OMP_THREADPRIVATE:
     D = OMPThreadPrivateDecl::CreateDeserialized(Context, ID, Record[Idx++]);
     break;
+  case DECL_OMP_DECLARETARGET:
+    D = OMPDeclareTargetDecl::CreateDeserialized(Context, ID);
+    break;
   case DECL_EMPTY:
     D = EmptyDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_OBJC_TYPE_PARAM:
     D = ObjCTypeParamDecl::CreateDeserialized(Context, ID);
     break;
   }
 
case UPD_STATIC_LOCAL_NUMBER:
       Reader.Context.setStaticLocalNumber(cast<VarDecl>(D), Record[Idx++]);
       break;
 
     case UPD_DECL_MARKED_OPENMP_THREADPRIVATE:
       D->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit(
           Reader.Context, ReadSourceRange(Record, Idx)));
       break;
 
+    case UPD_DECL_MARKED_OPENMP_DECLARETARGET:
+      D->addAttr(OMPDeclareTargetDeclAttr::CreateImplicit(
+          Reader.Context, ReadSourceRange(Record, Idx)));
+      break;
+
     case UPD_DECL_EXPORTED: {
       unsigned SubmoduleID = readSubmoduleID(Record, Idx);
       auto *Exported = cast<NamedDecl>(D);
       if (auto *TD = dyn_cast<TagDecl>(Exported))
         Exported = TD->getDefinition();
       Module *Owner = SubmoduleID ? Reader.getSubmodule(SubmoduleID) : nullptr;
       if (Reader.getContext().getLangOpts().ModulesLocalVisibility) {
         // FIXME: This doesn't send the right notifications if there are

lib/Serialization/ASTWriter.cpp

for (auto &Update : DeclUpdate.second) {
         Record.push_back(Update.getNumber());
         break;
 
       case UPD_DECL_MARKED_OPENMP_THREADPRIVATE:
         AddSourceRange(D->getAttr<OMPThreadPrivateDeclAttr>()->getRange(),
                        Record);
         break;
 
+    case UPD_DECL_MARKED_OPENMP_DECLARETARGET:
+        AddSourceRange(D->getAttr<OMPDeclareTargetDeclAttr>()->getRange(),
+                       Record);
+        break;
+
       case UPD_DECL_EXPORTED:
         Record.push_back(getSubmoduleID(Update.getModule()));
         break;
 
       case UPD_ADDED_ATTR_TO_RECORD:
         WriteAttributes(llvm::makeArrayRef(Update.getAttr()), Record);
         break;
       }

lib/Serialization/ASTWriterDecl.cpp

public:
     void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
     void VisitObjCImplDecl(ObjCImplDecl *D);
     void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
     void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
     void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
     void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
     void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
     void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
+    void VisitOMPDeclareTargetDecl(OMPDeclareTargetDecl *D);
 
     /// Add an Objective-C type parameter list to the given record.
     void AddObjCTypeParamList(ObjCTypeParamList *typeParams) {
       // Empty type parameter list.
       if (!typeParams) {
         Record.push_back(0);
         return;
       }

 void ASTDeclWriter::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
   Record.push_back(D->varlist_size());
   VisitDecl(D);
   for (auto *I : D->varlists())
     Writer.AddStmt(I);
   Code = serialization::DECL_OMP_THREADPRIVATE;
 }
 
+void ASTDeclWriter::VisitOMPDeclareTargetDecl(OMPDeclareTargetDecl *D) {
+  VisitDecl(D);
+  Code = serialization::DECL_OMP_DECLARETARGET;
+}
+
 //===----------------------------------------------------------------------===//
 // ASTWriter Implementation
 //===----------------------------------------------------------------------===//
 
 void ASTWriter::WriteDeclAbbrevs() {
   using namespace llvm;
 
   BitCodeAbbrev *Abv;

 /// clients to use a separate API call to "realize" the decl. This should be
 /// relatively painless since they would presumably only do it for top-level
 /// decls.
 static bool isRequiredDecl(const Decl *D, ASTContext &Context,
                            bool WritingModule) {
   // An ObjCMethodDecl is never considered as "required" because its
   // implementation container always is.
 
-  // File scoped assembly or obj-c implementation must be seen.
-  if (isa<FileScopeAsmDecl>(D) || isa<ObjCImplDecl>(D))
+  // File scoped assembly or obj-c or OMP Declare target implementation must be seen.
+  if (isa<FileScopeAsmDecl>(D) || isa<ObjCImplDecl>(D) || isa<OMPDeclareTargetDecl>(D))
     return true;
 
   // ImportDecl is used by codegen to determine the set of imported modules to
   // search for inputs for automatic linking; include it if it has a semantic
   // effect.
   if (isa<ImportDecl>(D) && !WritingModule)
     return true;
 

test/OpenMP/declare_target_ast_print.cpp

+// RUN: %clang_cc1 -verify -fopenmp -ast-print %s | FileCheck %s
+// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -emit-pch -o %t %s
+// RUN: %clang_cc1 -fopenmp -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
+// expected-no-diagnostics
+
+#ifndef HEADER
+#define HEADER
+
+#pragma omp declare target
+// CHECK: #pragma omp declare target
+
+void foo() {}
+// CHECK-NEXT: void foo()
+
+#pragma omp end declare target
+// CHECK: #pragma omp end declare target
+
+extern "C" {
+#pragma omp declare target
+// CHECK: #pragma omp declare target
+
+void foo_c() {}
+// CHECK-NEXT: void foo_c()
+
+#pragma omp end declare target
+// CHECK: #pragma omp end declare target
+}
+
+extern "C++" {
+#pragma omp declare target
+// CHECK: #pragma omp declare target
+
+void foo_cpp() {}
+// CHECK-NEXT: void foo_cpp()
+
+#pragma omp end declare target
+// CHECK: #pragma omp end declare target
+}
+
+int main (int argc, char **argv) {
+  foo();
+  foo_c();
+  foo_cpp();
+  return (0);
+}
+
+#endif

test/OpenMP/declare_target_messages.cpp

+// RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -verify -fopenmp -fnoopenmp-use-tls -ferror-limit 100 -o - %s
+
+#pragma omp end declare target // expected-error {{unexpected OpenMP directive '#pragma omp end declare target'}}
+
+int a, b; // expected-warning 2 {{declaration is not declared in any declare target region}}
+__thread int t; // expected-error {{threadprivate variables cannot be used in target constructs}}
+#pragma omp declare target private(a) // expected-warning {{extra tokens at the end of '#pragma omp declare target' are ignored}}
+void f();
+#pragma omp end declare target shared(a) // expected-warning {{extra tokens at the end of '#pragma omp end declare target' are ignored}}
+void c(); // expected-warning {{declaration is not declared in any declare target region}}
+
+extern int b;
+
+struct NonT {
+  int a;
+};
+
+typedef int sint;
+
+#pragma omp declare target // expected-note {{to match this '#pragma omp declare target'}}
+#pragma omp threadprivate(a) // expected-error {{threadprivate variables cannot be used in target constructs}} expected-note {{used here}}
+extern int b;
+int g;
+
+struct T { // expected-note {{mappable type cannot be polymorphic}}
+  int a;
+  virtual int method();
+};
+
+class VC { // expected-note {{mappable type cannot be polymorphic}}
+  T member;
+  NonT member1;
+  public:
+    virtual int method() { T a; return 0; } // expected-error {{type 'T' is not mappable to target}}
+};
+
+struct C {
+  NonT a;
+  sint b;
+  int method();
+  int method1();
+};
+
+int C::method1() {
+  return 0;
+}
+
+void foo() {
+  a = 0; // expected-note {{used here}}
+  b = 0; // expected-note {{used here}}
+  t = 1; // expected-note {{used here}}
+  C object;
+  VC object1; // expected-error {{type 'VC' is not mappable to target}}
+  g = object.method();
+  g += object.method1();
+  g += object1.method();
+  f();
+  c(); // expected-note {{used here}}
+}
+#pragma omp declare target // expected-error {{expected '#pragma omp end declare target'}}
+void foo1() {}
+#pragma omp end declare target
+#pragma omp end declare target // expected-error {{unexpected OpenMP directive '#pragma omp end declare target'}}
+
+int C::method() {
+  return 0;
+}
+
+struct S {
+#pragma omp declare target // expected-error {{directive must be at file or namespace scope}}
+  int v;
+#pragma omp end declare target // expected-error {{unexpected OpenMP directive '#pragma omp end declare target'}}
+};
+
+int main (int argc, char **argv) {
+#pragma omp declare target // expected-error {{unexpected OpenMP directive '#pragma omp declare target'}}
+  int v;
+#pragma omp end declare target // expected-error {{unexpected OpenMP directive '#pragma omp end declare target'}}
+  foo();
+  return (0);
+}
+
+#pragma omp declare target // expected-error {{expected '#pragma omp end declare target'}} expected-note {{to match this '#pragma omp declare target'}}

tools/libclang/CIndex.cpp

CXCursor clang_getCursorDefinition(CXCursor C) {
   case Decl::FileScopeAsm:
   case Decl::StaticAssert:
   case Decl::Block:
   case Decl::Captured:
   case Decl::Label:  // FIXME: Is this right??
   case Decl::ClassScopeFunctionSpecialization:
   case Decl::Import:
   case Decl::OMPThreadPrivate:
+  case Decl::OMPDeclareTarget:
   case Decl::ObjCTypeParam:
   case Decl::BuiltinTemplate:
     return C;
 
   // Declaration kinds that don't make any sense here, but are
   // nonetheless harmless.
   case Decl::Empty:
   case Decl::TranslationUnit: