[Sema] #pragma clang transform

[Meinersbur]

Summary

Add the AST node kinds: the Stmt representing the #pragma, the clauses and Transform. The latter represents the semantic analysis result similar to an ImplicitCast. Moreover, the AnalysisTransform component constructs a loop nest tree to which transformations are applied to such that Sema can warn about inconsistencies, e.g. there is no inner or ambiguous loops for unrollandjam.

For a full description, see D69088.

[Meinersbur]

• Switch to Monorepo
• Move Transform.h/cpp to clangBasic
• Transform is not an AST node anymore, but created on demand using ExtractTransform

[Meinersbur]

ping

[Meinersbur]

• Remove handling of LoopHints (#pragma clang loop) and OpenMP (#pragma omp simd) to reduce the size of the patches. Compatibility with OpenMP is still a goal (to implement the upcoming OpenMP loop transformations such as #pragma omp tile), but for now they are handled by separate code paths.

[Meinersbur]

• Rework TransformedTree a bit

include/clang/AST/ASTNodeTraverser.h

struct {
   void Visit(const Stmt *Node);
   void Visit(const Type *T);
   void Visit(QualType T);
   void Visit(const Decl *D);
   void Visit(const CXXCtorInitializer *Init);
   void Visit(const OMPClause *C);
   void Visit(const BlockDecl::Capture &C);
   void Visit(const GenericSelectionExpr::ConstAssociation &A);
+  void Visit(const TransformClause *C);
+  void Visit(const Transform *T);
 };
 */
 template <typename Derived, typename NodeDelegateType>
 class ASTNodeTraverser
     : public ConstDeclVisitor<Derived>,
       public ConstStmtVisitor<Derived>,
       public comments::ConstCommentVisitor<Derived, void,
                                            const comments::FullComment *>,
getNodeDelegate().AddChild([=] {
                                                                           FC);
       for (comments::Comment::child_iterator I = C->child_begin(),
                                              E = C->child_end();
            I != E; ++I)
         Visit(*I, FC);
     });
   }
 
+  void Visit(const TransformClause *C) {
+    getNodeDelegate().AddChild([=] {
+      getNodeDelegate().Visit(C);
+      for (const auto *S : C->children())
+        Visit(S);
+    });
+  }
+
+  void Visit(const Transform *T) {
+    getNodeDelegate().AddChild([=] {
+      getNodeDelegate().Visit(T);
+      for (const auto *S : T->children())
+        Visit(S);
+    });
+  }
+
   void Visit(const ast_type_traits::DynTypedNode &N) {
     // FIXME: Improve this with a switch or a visitor pattern.
     if (const auto *D = N.get<Decl>())
       Visit(D);
     else if (const auto *S = N.get<Stmt>())
       Visit(S);
     else if (const auto *QT = N.get<QualType>())
       Visit(*QT);
     else if (const auto *T = N.get<Type>())
       Visit(T);
     else if (const auto *C = N.get<CXXCtorInitializer>())
       Visit(C);
     else if (const auto *C = N.get<OMPClause>())
       Visit(C);
     else if (const auto *T = N.get<TemplateArgument>())
       Visit(*T);
+    else if (const auto *C = N.get<TransformClause>())
+      Visit(C);
+    else if (const auto *T = N.get<Transform>())
+      Visit(T);
   }
 
   void dumpDeclContext(const DeclContext *DC) {
     if (!DC)
       return;
 
     for (const auto *D : (Deserialize ? DC->decls() : DC->noload_decls()))
       Visit(D);
void VisitCapturedStmt(const CapturedStmt *Node) {
     Visit(Node->getCapturedDecl());
   }
 
   void VisitOMPExecutableDirective(const OMPExecutableDirective *Node) {
     for (const auto *C : Node->clauses())
       Visit(C);
   }
 
+  void
+  VisitTransformExecutableDirective(const TransformExecutableDirective *Node) {
+    for (const auto *C : Node->clauses())
+      Visit(C);
+  }
+
   void VisitInitListExpr(const InitListExpr *ILE) {
     if (auto *Filler = ILE->getArrayFiller()) {
       Visit(Filler, "array_filler");
     }
   }
 
   void VisitBlockExpr(const BlockExpr *Node) { Visit(Node->getBlockDecl()); }
 

include/clang/AST/ASTTypeTraits.h

 #ifndef LLVM_CLANG_AST_ASTTYPETRAITS_H
 #define LLVM_CLANG_AST_ASTTYPETRAITS_H
 
 #include "clang/AST/ASTFwd.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/OpenMPClause.h"
 #include "clang/AST/Stmt.h"
+#include "clang/AST/StmtTransform.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/Support/AlignOf.h"
 
 namespace llvm {
 
public:
   }
 
   /// \{
   /// Construct an identifier for the dynamic type of the node
   static ASTNodeKind getFromNode(const Decl &D);
   static ASTNodeKind getFromNode(const Stmt &S);
   static ASTNodeKind getFromNode(const Type &T);
   static ASTNodeKind getFromNode(const OMPClause &C);
+  static ASTNodeKind getFromNode(const TransformClause &C);
+  static ASTNodeKind getFromNode(const Transform &T);
   /// \}
 
   /// Returns \c true if \c this and \c Other represent the same kind.
   bool isSame(ASTNodeKind Other) const {
     return KindId != NKI_None && KindId == Other.KindId;
   }
 
   /// Returns \c true only for the default \c ASTNodeKind()

 #define STMT(DERIVED, BASE) NKI_##DERIVED,
 #include "clang/AST/StmtNodes.inc"
     NKI_Type,
 #define TYPE(DERIVED, BASE) NKI_##DERIVED##Type,
 #include "clang/AST/TypeNodes.inc"
     NKI_OMPClause,
 #define OPENMP_CLAUSE(TextualSpelling, Class) NKI_##Class,
 #include "clang/Basic/OpenMPKinds.def"
+    NKI_TransformClause,
+#define TRANSFORM_CLAUSE(Keyword, Name) NKI_##Name##Clause,
+#include "clang/AST/TransformKinds.def"
+    NKI_Transform,
+#define TRANSFORM_DIRECTIVE(Keyworld, Name) NKI_##Name##Transform,
+#include "clang/AST/TransformKinds.def"
     NKI_NumberOfKinds
   };
 
   /// Use getFromNodeKind<T>() to construct the kind.
   ASTNodeKind(NodeKindId KindId) : KindId(KindId) {}
 
   /// Returns \c true if \c Base is a base kind of (or same as) \c
   ///   Derived.

 #define DECL(DERIVED, BASE) KIND_TO_KIND_ID(DERIVED##Decl)
 #include "clang/AST/DeclNodes.inc"
 #define STMT(DERIVED, BASE) KIND_TO_KIND_ID(DERIVED)
 #include "clang/AST/StmtNodes.inc"
 #define TYPE(DERIVED, BASE) KIND_TO_KIND_ID(DERIVED##Type)
 #include "clang/AST/TypeNodes.inc"
 #define OPENMP_CLAUSE(TextualSpelling, Class) KIND_TO_KIND_ID(Class)
 #include "clang/Basic/OpenMPKinds.def"
+#define TRANSFORM_CLAUSE(Keyword, Name) KIND_TO_KIND_ID(Name##Clause)
+#include "clang/AST/TransformKinds.def"
+#define TRANSFORM_DIRECTIVE(Keyworld, Name) KIND_TO_KIND_ID(Name##Transform)
+#include "clang/AST/TransformKinds.def"
 #undef KIND_TO_KIND_ID
 
 inline raw_ostream &operator<<(raw_ostream &OS, ASTNodeKind K) {
   OS << K.asStringRef();
   return OS;
 }
 
 /// A dynamically typed AST node container.

include/clang/AST/JSONNodeDumper.h

public:
 
   void Visit(const comments::Comment *C, const comments::FullComment *FC);
   void Visit(const TemplateArgument &TA, SourceRange R = {},
              const Decl *From = nullptr, StringRef Label = {});
   void Visit(const CXXCtorInitializer *Init);
   void Visit(const OMPClause *C);
   void Visit(const BlockDecl::Capture &C);
   void Visit(const GenericSelectionExpr::ConstAssociation &A);
+  void Visit(const TransformClause *C);
+  void Visit(const Transform *T);
 
   void VisitTypedefType(const TypedefType *TT);
   void VisitFunctionType(const FunctionType *T);
   void VisitFunctionProtoType(const FunctionProtoType *T);
   void VisitRValueReferenceType(const ReferenceType *RT);
   void VisitArrayType(const ArrayType *AT);
   void VisitConstantArrayType(const ConstantArrayType *CAT);
   void VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *VT);

include/clang/AST/RecursiveASTVisitor.h

 #include "clang/AST/ExprOpenMP.h"
 #include "clang/AST/LambdaCapture.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/OpenMPClause.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/AST/StmtObjC.h"
 #include "clang/AST/StmtOpenMP.h"
+#include "clang/AST/StmtTransform.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/TemplateName.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/OpenMPKinds.h"
 #include "clang/Basic/Specifiers.h"
 #include "llvm/ADT/PointerIntPair.h"

 #define OPENMP_CLAUSE(Name, Class) bool Visit##Class(Class *C);
 #include "clang/Basic/OpenMPKinds.def"
   /// Process clauses with list of variables.
   template <typename T> bool VisitOMPClauseList(T *Node);
   /// Process clauses with pre-initis.
   bool VisitOMPClauseWithPreInit(OMPClauseWithPreInit *Node);
   bool VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *Node);
 
+  bool TraverseTransformClause(TransformClause *C);
+#define TRANSFORM_CLAUSE(Keyword, Name)                                        \
+  bool Visit##Name##Clause(Name##Clause *C);
+#include "clang/AST/TransformKinds.def"
+
+  bool TraverseTransform(Transform *T);
+#define TRANSFORM_DIRECTIVE(Keyword, Name)                                     \
+  bool Visit##Name##Transform(Name##Transform *T);
+#include "clang/AST/TransformKinds.def"
+
   bool dataTraverseNode(Stmt *S, DataRecursionQueue *Queue);
   bool PostVisitStmt(Stmt *S);
 };
 
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::dataTraverseNode(Stmt *S,
                                                     DataRecursionQueue *Queue) {
 #define DISPATCH_STMT(NAME, CLASS, VAR)                                        \

 DEF_TRAVERSE_STMT(ObjCStringLiteral, {})
 DEF_TRAVERSE_STMT(ObjCBoxedExpr, {})
 DEF_TRAVERSE_STMT(ObjCArrayLiteral, {})
 DEF_TRAVERSE_STMT(ObjCDictionaryLiteral, {})
 
 // Traverse OpenCL: AsType, Convert.
 DEF_TRAVERSE_STMT(AsTypeExpr, {})
 
+DEF_TRAVERSE_STMT(TransformExecutableDirective, {
+  TRY_TO(TraverseTransform(S->getTransform()));
+  for (auto *C : S->clauses())
+    TRY_TO(TraverseTransformClause(C));
+})
+
 // OpenMP directives.
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseOMPExecutableDirective(
     OMPExecutableDirective *S) {
   for (auto *C : S->clauses()) {
     TRY_TO(TraverseOMPClause(C));
   }
   return true;
DEF_TRAVERSE_STMT(OMPTargetTeamsDistributeParallelForDirective,
                   { TRY_TO(TraverseOMPExecutableDirective(S)); })
 
 DEF_TRAVERSE_STMT(OMPTargetTeamsDistributeParallelForSimdDirective,
                   { TRY_TO(TraverseOMPExecutableDirective(S)); })
 
 DEF_TRAVERSE_STMT(OMPTargetTeamsDistributeSimdDirective,
                   { TRY_TO(TraverseOMPExecutableDirective(S)); })
 
+template <typename Derived>
+bool RecursiveASTVisitor<Derived>::TraverseTransform(Transform *T) {
+  if (!T)
+    return true;
+  switch (T->getKind()) {
+  case Transform::Kind::UnknownKind:
+    llvm_unreachable("Cannot process unknown transformation");
+#define TRANSFORM_DIRECTIVE(Keyword, Name)                                     \
+  case Transform::Kind::Name##Kind:                                            \
+    TRY_TO(Visit##Name##Transform(static_cast<Name##Transform *>(T)));         \
+    break;
+#include "clang/AST/TransformKinds.def"
+  }
+  return true;
+}
+
+template <typename Derived>
+bool RecursiveASTVisitor<Derived>::TraverseTransformClause(TransformClause *C) {
+  if (!C)
+    return true;
+  switch (C->getKind()) {
+  case TransformClause::Kind::UnknownKind:
+    llvm_unreachable("Cannot process unknown clause");
+#define TRANSFORM_CLAUSE(Keyword, Name)                                        \
+  case TransformClause::Kind::Name##Kind:                                      \
+    TRY_TO(Visit##Name##Clause(static_cast<Name##Clause *>(C)));               \
+    break;
+#include "clang/AST/TransformKinds.def"
+  }
+  return true;
+}
+
 // OpenMP clauses.
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {
   if (!C)
     return true;
   switch (C->getClauseKind()) {
 #define OPENMP_CLAUSE(Name, Class)                                             \
   case OMPC_##Name:                                                            \

 
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::VisitOMPIsDevicePtrClause(
     OMPIsDevicePtrClause *C) {
   TRY_TO(VisitOMPClauseList(C));
   return true;
 }
 
+template <typename Derived>
+bool RecursiveASTVisitor<Derived>::VisitFullClause(FullClause *C) {
+  return true;
+}
+
+template <typename Derived>
+bool RecursiveASTVisitor<Derived>::VisitPartialClause(PartialClause *C) {
+  TRY_TO(TraverseStmt(C->getFactor()));
+  return true;
+}
+
+template <typename Derived>
+bool RecursiveASTVisitor<Derived>::VisitWidthClause(WidthClause *C) {
+  TRY_TO(TraverseStmt(C->getWidth()));
+  return true;
+}
+
+template <typename Derived>
+bool RecursiveASTVisitor<Derived>::VisitFactorClause(FactorClause *C) {
+  TRY_TO(TraverseStmt(C->getFactor()));
+  return true;
+}
+
+#define TRANSFORM_DIRECTIVE(Keyword, Name)                                     \
+  template <typename Derived>                                                  \
+  bool RecursiveASTVisitor<Derived>::Visit##Name##Transform(                   \
+      Name##Transform *T) {                                                    \
+    return true;                                                               \
+  }
+#include "clang/AST/TransformKinds.def"
+
 // FIXME: look at the following tricky-seeming exprs to see if we
 // need to recurse on anything.  These are ones that have methods
 // returning decls or qualtypes or nestednamespecifier -- though I'm
 // not sure if they own them -- or just seemed very complicated, or
 // had lots of sub-types to explore.
 //
 // VisitOverloadExpr and its children: recurse on template args? etc?
 

include/clang/AST/StmtTransform.h

 //===--- StmtTransform.h - Code transformation AST nodes --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  Transformation directive statement and clauses for the AST.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_STMTTRANSFROM_H
 #define LLVM_CLANG_AST_STMTTRANSFROM_H
 
+#include "clang/AST/Expr.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/Transform.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace clang {
 
 /// Represents a clause of a \p TransformExecutableDirective.
 class TransformClause {
 public:
   enum Kind {
     UnknownKind,
 #define TRANSFORM_CLAUSE(Keyword, Name) Name##Kind,
 #define TRANSFORM_CLAUSE_LAST(Keyword, Name) Name##Kind, LastKind = Name##Kind
 #include "clang/AST/TransformKinds.def"
   };
 
   static bool isValidForTransform(Transform::Kind TransformKind,
                                   TransformClause::Kind ClauseKind);
   static Kind getClauseKind(Transform::Kind TransformKind, llvm::StringRef Str);
 
-  // TODO: implement
+private:
+  Kind ClauseKind;
+  SourceRange Loc;
+
+protected:
+  TransformClause(Kind K, SourceRange Loc) : ClauseKind(K), Loc(Loc) {}
+  TransformClause(Kind K) : ClauseKind(K) {}
+
+public:
+  Kind getKind() const { return ClauseKind; }
+
+  SourceRange getLoc() const { return Loc; }
+  SourceLocation getBeginLoc() const { return Loc.getBegin(); }
+  SourceLocation getEndLoc() const { return Loc.getEnd(); }
+
+  void setLoc(SourceLocation BeginLoc, SourceLocation EndLoc) {
+    Loc = SourceRange(BeginLoc, EndLoc);
+  }
+  void setLoc(SourceRange L) { Loc = L; }
+
+  using child_iterator = Stmt::child_iterator;
+  using const_child_iterator = Stmt::const_child_iterator;
+  using child_range = Stmt::child_range;
+  using const_child_range = Stmt::const_child_range;
+
+  child_range children();
+  const_child_range children() const {
+    auto Children = const_cast<TransformClause *>(this)->children();
+    return const_child_range(Children.begin(), Children.end());
+  }
+
+  static llvm::StringRef getClauseName(Kind K);
+
+  void print(llvm::raw_ostream &OS, const PrintingPolicy &Policy) const;
+};
+
+class TransformClauseImpl : public TransformClause {
+protected:
+  TransformClauseImpl(Kind ClauseKind, SourceRange Range)
+      : TransformClause(ClauseKind, Range) {}
+  explicit TransformClauseImpl(Kind ClauseKind) : TransformClause(ClauseKind) {}
+
+public:
+  void print(llvm::raw_ostream &OS, const PrintingPolicy &Policy) const {
+    llvm_unreachable("implement the print function");
+  }
+
+  child_range children() {
+    // By default, clauses have no children.
+    return child_range(child_iterator(), child_iterator());
+  }
+};
+
+class FullClause final : public TransformClauseImpl {
+private:
+  explicit FullClause(SourceRange Range)
+      : TransformClauseImpl(TransformClause::FullKind, Range) {}
+  FullClause() : TransformClauseImpl(TransformClause::FullKind) {}
+
+public:
+  static bool classof(const FullClause *T) { return true; }
+  static bool classof(const TransformClause *T) {
+    return T->getKind() == FullKind;
+  }
+
+  static FullClause *create(ASTContext &Context, SourceRange Range) {
+    return new (Context) FullClause(Range);
+  }
+  static FullClause *createEmpty(ASTContext &Context) {
+    return new (Context) FullClause();
+  }
+
+  void print(llvm::raw_ostream &OS, const PrintingPolicy &Policy) const;
+};
+
+class PartialClause final : public TransformClauseImpl {
+private:
+  Stmt *Factor;
+
+  PartialClause(SourceRange Range, Expr *Factor)
+      : TransformClauseImpl(TransformClause::PartialKind, Range),
+        Factor(Factor) {}
+  PartialClause() : TransformClauseImpl(TransformClause::PartialKind) {}
+
+public:
+  static bool classof(const PartialClause *T) { return true; }
+  static bool classof(const TransformClause *T) {
+    return T->getKind() == PartialKind;
+  }
+
+  static PartialClause *create(ASTContext &Context, SourceRange Range,
+                               Expr *Factor) {
+    return new (Context) PartialClause(Range, Factor);
+  }
+  static PartialClause *createEmpty(ASTContext &Context) {
+    return new (Context) PartialClause();
+  }
+
+  child_range children() { return child_range(&Factor, &Factor + 1); }
+
+  Expr *getFactor() const { return cast<Expr>(Factor); }
+  void setFactor(Expr *E) { Factor = E; }
+
+  void print(llvm::raw_ostream &OS, const PrintingPolicy &Policy) const;
+};
+
+class WidthClause final : public TransformClauseImpl {
+private:
+  Stmt *Width;
+
+  WidthClause(SourceRange Range, Expr *Width)
+      : TransformClauseImpl(TransformClause::WidthKind, Range), Width(Width) {}
+  WidthClause() : TransformClauseImpl(TransformClause::WidthKind) {}
+
+public:
+  static bool classof(const WidthClause *T) { return true; }
+  static bool classof(const TransformClause *T) {
+    return T->getKind() == WidthKind;
+  }
+
+  static WidthClause *create(ASTContext &Context, SourceRange Range,
+                             Expr *Width) {
+    return new (Context) WidthClause(Range, Width);
+  }
+  static WidthClause *createEmpty(ASTContext &Context) {
+    return new (Context) WidthClause();
+  }
+
+  child_range children() { return child_range(&Width, &Width + 1); }
+
+  Expr *getWidth() const { return cast<Expr>(Width); }
+  void setWidth(Expr *E) { Width = E; }
+
+  void print(llvm::raw_ostream &OS, const PrintingPolicy &Policy) const;
+};
+
+class FactorClause final : public TransformClauseImpl {
+private:
+  Stmt *Factor;
+
+  FactorClause(SourceRange Range, Expr *Factor)
+      : TransformClauseImpl(TransformClause::FactorKind, Range),
+        Factor(Factor) {}
+  FactorClause() : TransformClauseImpl(TransformClause::FactorKind) {}
+
+public:
+  static bool classof(const FactorClause *T) { return true; }
+  static bool classof(const TransformClause *T) {
+    return T->getKind() == FactorKind;
+  }
+
+  static FactorClause *create(ASTContext &Context, SourceRange Range,
+                              Expr *Factor) {
+    return new (Context) FactorClause(Range, Factor);
+  }
+  static FactorClause *createEmpty(ASTContext &Context) {
+    return new (Context) FactorClause();
+  }
+
+  child_range children() { return child_range(&Factor, &Factor + 1); }
+
+  Expr *getFactor() const { return cast<Expr>(Factor); }
+  void setFactor(Expr *E) { Factor = E; }
+
+  void print(llvm::raw_ostream &OS, const PrintingPolicy &Policy) const;
 };
 
 /// Represents
 ///
 ///   #pragma clang transform
 ///
 /// in the AST.
-class TransformExecutableDirective final {
-  // TODO: implement
+class TransformExecutableDirective final
+    : public Stmt,
+      private llvm::TrailingObjects<TransformExecutableDirective,
+                                    TransformClause *> {
+public:
+  friend TransformClause;
+  friend TrailingObjects;
+
+private:
+  SourceRange Range;
+  Stmt *Associated = nullptr;
+  Transform *Trans = nullptr;
+  Transform::Kind TransKind = Transform::Kind::UnknownKind;
+  unsigned NumClauses;
+
+protected:
+  explicit TransformExecutableDirective(SourceRange Range, Stmt *Associated,
+                                        Transform *Trans,
+                                        ArrayRef<TransformClause *> Clauses,
+                                        Transform::Kind TransKind)
+      : Stmt(Stmt::TransformExecutableDirectiveClass), Range(Range),
+        Associated(Associated), Trans(Trans), TransKind(TransKind),
+        NumClauses(Clauses.size()) {
+    setClauses(Clauses);
+  }
+  explicit TransformExecutableDirective(unsigned NumClauses)
+      : Stmt(Stmt::StmtClass::TransformExecutableDirectiveClass),
+        NumClauses(NumClauses) {}
+
+  size_t numTrailingObjects(OverloadToken<TransformClause *>) const {
+    return NumClauses;
+  }
+
+public:
+  static bool classof(const TransformExecutableDirective *T) { return true; }
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == Stmt::TransformExecutableDirectiveClass;
+  }
+
+  static TransformExecutableDirective *
+  create(ASTContext &Ctx, SourceRange Range, Stmt *Associated, Transform *Trans,
+         ArrayRef<TransformClause *> Clauses, Transform::Kind TransKind);
+  static TransformExecutableDirective *createEmpty(ASTContext &Ctx,
+                                                   unsigned NumClauses);
+
+  SourceRange getLoc() const { return Range; }
+  SourceLocation getBeginLoc() const { return Range.getBegin(); }
+  SourceLocation getEndLoc() const { return Range.getEnd(); }
+  void setLoc(SourceRange Loc) { Range = Loc; }
+  void setLoc(SourceLocation BeginLoc, SourceLocation EndLoc) {
+    Range = SourceRange(BeginLoc, EndLoc);
+  }
+
+  Stmt *getAssociated() const { return Associated; }
+  void setAssociated(Stmt *S) { Associated = S; }
+
+  Transform *getTransform() const { return Trans; }
+  Transform::Kind getTransformKind() const { return TransKind; }
+
+  child_range children() { return child_range(&Associated, &Associated + 1); }
+  const_child_range children() const {
+    return const_child_range(&Associated, &Associated + 1);
+  }
+
+  unsigned getNumClauses() const { return NumClauses; }
+  MutableArrayRef<TransformClause *> clauses() {
+    return llvm::makeMutableArrayRef(getTrailingObjects<TransformClause *>(),
+                                     NumClauses);
+  }
+  ArrayRef<TransformClause *> clauses() const {
+    return llvm::makeArrayRef(getTrailingObjects<TransformClause *>(),
+                              NumClauses);
+  }
+
+  void setClauses(llvm::ArrayRef<TransformClause *> List) {
+    assert(List.size() == NumClauses);
+    for (auto p : llvm::zip_first(List, clauses()))
+      std::get<1>(p) = std::get<0>(p);
+  }
+
+  auto getClausesOfKind(TransformClause::Kind Kind) const {
+    return llvm::make_filter_range(clauses(), [Kind](TransformClause *Clause) {
+      return Clause->getKind() == Kind;
+    });
+  }
+
+  template <typename SpecificClause> auto getClausesOfKind() const {
+    return llvm::map_range(
+        llvm::make_filter_range(clauses(),
+                                [](TransformClause *Clause) {
+                                  return isa<SpecificClause>(Clause);
+                                }),
+        [](TransformClause *Clause) { return cast<SpecificClause>(Clause); });
+  }
+
+  template <typename SpecificClause>
+  SpecificClause *getFirstClauseOfKind() const {
+    auto Range = getClausesOfKind<SpecificClause>();
+    if (Range.begin() == Range.end())
+      return nullptr;
+    return *Range.begin();
+  }
 };
 
 const Stmt *getAssociatedLoop(const Stmt *S);
 } // namespace clang
 
 #endif /* LLVM_CLANG_AST_STMTTRANSFROM_H */

include/clang/AST/TextNodeDumper.h

public:
   void Visit(QualType T);
 
   void Visit(const Decl *D);
 
   void Visit(const CXXCtorInitializer *Init);
 
   void Visit(const OMPClause *C);
 
+  void VisitTransformExecutableDirective(const TransformExecutableDirective *S);
+
+  void Visit(const TransformClause *C);
+
+  void Visit(const Transform *T);
+
   void Visit(const BlockDecl::Capture &C);
 
   void Visit(const GenericSelectionExpr::ConstAssociation &A);
 
   void dumpPointer(const void *Ptr);
   void dumpLocation(SourceLocation Loc);
   void dumpSourceRange(SourceRange R);
   void dumpBareType(QualType T, bool Desugar = true);

include/clang/AST/Transform.h

 //===--- Transform.h - Code transformation classes --------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines classes used for code transformations such as
 //  #pragma clang transform ...
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_TRANSFORM_H
 #define LLVM_CLANG_AST_TRANSFORM_H
 
+#include "clang/AST/Stmt.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace clang {
 
 class Transform {
 public:
   enum Kind {
     UnknownKind,
 #define TRANSFORM_DIRECTIVE(Keyword, Name) Name##Kind,
 #define TRANSFORM_DIRECTIVE_LAST(Keyword, Name)                                \
   TRANSFORM_DIRECTIVE(Keyword, Name)                                           \
   LastKind = Name##Kind
 #include "clang/AST/TransformKinds.def"
   };
 
   static Kind getTransformDirectiveKind(llvm::StringRef Str);
   static llvm::StringRef getTransformDirectiveKeyword(Kind K);
   static llvm::StringRef getTransformDirectiveName(Kind K);
 
-  // TODO: implement
+private:
+  Kind TransformKind;
+  SourceRange Loc;
+  bool IsLegacy;
+
+public:
+  Transform(Kind K, SourceRange Loc, bool IsLegacy)
+      : TransformKind(K), Loc(Loc), IsLegacy(IsLegacy) {}
+
+  Kind getKind() const { return TransformKind; }
+  static bool classof(const Transform *Trans) { return true; }
+
+  /// Source location of the code transformation directive.
+  /// @{
+  SourceRange getLoc() const { return Loc; }
+  SourceLocation getBeginLoc() const { return Loc.getBegin(); }
+  SourceLocation getEndLoc() const { return Loc.getEnd(); }
+
+  void setLoc(SourceLocation BeginLoc, SourceLocation EndLoc) {
+    Loc = SourceRange(BeginLoc, EndLoc);
+  }
+  void setLoc(SourceRange L) { Loc = L; }
+  /// @}
+
+  /// Non-legacy directives originate from a #pragma clang transform directive.
+  /// Legacy transformations are introduced by #pragma clang loop,
+  /// #pragma omp simd, #pragma unroll, etc.
+  /// Differences include:
+  ///  * Legacy directives transformation execution order is defined by the
+  ///    compiler.
+  ///  * Some warnings that clang historically did not warn about are disabled.
+  ///  * Some differences of the emitted loop metadata for compatibility.
+  bool isLegacy() const { return IsLegacy; }
+
+  using child_iterator = Stmt::child_iterator;
+  using const_child_iterator = Stmt::const_child_iterator;
+  using child_range = Stmt::child_range;
+  using const_child_range = Stmt::const_child_range;
+
+  child_range children() {
+    return child_range(child_iterator(), child_iterator());
+  }
+  const_child_range children() const {
+    return const_child_range(child_iterator(), child_iterator());
+  }
+
+  /// Each transformation defines how many loops it consumes and generates.
+  /// Users of this class can store arrays holding the information regarding the
+  /// loops, such as pointer to the AST node or the loop name. The index in this
+  /// array is its "role".
+  /// @{
+  int getNumInputs() const;
+  int getNumFollowups() const;
+  /// @}
+
+  /// The "all" follow-up role is a meta output whose' attributes are added to
+  /// all generated loops.
+  bool isAllRole(int R) const { return R == 0; }
+
+  /// Used to warn users that the current LLVM pass pipeline cannot apply
+  /// arbitrary transformation orders yet.
+  int getLoopPipelineStage() const;
+};
+
+/// Default implementation of compile-time inherited methods to avoid infinite
+/// recursion.
+class TransformImpl : public Transform {
+public:
+  TransformImpl(Kind K, SourceRange Loc, bool IsLegacy)
+      : Transform(K, Loc, IsLegacy) {}
+
+  int getNumInputs() const { return 1; }
+  int getNumFollowups() const { return 1; }
+};
+
+class LoopDistributionTransform final : public TransformImpl {
+private:
+  LoopDistributionTransform(SourceRange Loc, bool IsLegacy)
+      : TransformImpl(LoopDistributionKind, Loc, IsLegacy) {}
+
+public:
+  static bool classof(const LoopDistributionTransform *Trans) { return true; }
+  static bool classof(const Transform *Trans) {
+    return Trans->getKind() == LoopDistributionKind;
+  }
+
+  static LoopDistributionTransform *create(SourceRange Loc, bool IsLegacy) {
+    return new LoopDistributionTransform(Loc, IsLegacy);
+  }
+
+  enum Input {
+    InputToDistribute,
+  };
+  enum Followup {
+    FollowupAll,
+  };
+};
+
+class LoopVectorizationTransform final : public TransformImpl {
+private:
+  llvm::Optional<bool> EnableVectorization;
+  int VectorizeWidth;
+  llvm::Optional<bool> VectorizePredicateEnable;
+
+  LoopVectorizationTransform(SourceRange Loc,
+                             llvm::Optional<bool> EnableVectorization,
+                             int VectorizeWidth,
+                             llvm::Optional<bool> VectorizePredicateEnable)
+      : TransformImpl(LoopVectorizationKind, Loc, true),
+        EnableVectorization(EnableVectorization),
+        VectorizeWidth(VectorizeWidth),
+        VectorizePredicateEnable(VectorizePredicateEnable) {}
+
+public:
+  static bool classof(const LoopVectorizationTransform *Trans) { return true; }
+  static bool classof(const Transform *Trans) {
+    return Trans->getKind() == LoopVectorizationKind;
+  }
+
+  static LoopVectorizationTransform *
+  Create(SourceRange Loc, llvm::Optional<bool> EnableVectorization,
+         int VectorizeWidth, llvm::Optional<bool> VectorizePredicateEnable) {
+    assert(EnableVectorization.getValueOr(true));
+    return new LoopVectorizationTransform(
+        Loc, EnableVectorization, VectorizeWidth, VectorizePredicateEnable);
+  }
+
+  int getNumInputs() const { return 1; }
+  int getNumFollowups() const { return 3; }
+  enum Input {
+    InputToVectorize,
+  };
+  enum Followup { FollowupAll, FollowupVectorized, FollowupEpilogue };
+
+  llvm::Optional<bool> isVectorizationEnabled() const {
+    return EnableVectorization;
+  }
+
+  int getWidth() const { return VectorizeWidth; }
+
+  llvm::Optional<bool> isPredicateEnabled() const {
+    return VectorizePredicateEnable;
+  }
+};
+
+class LoopInterleavingTransform final : public TransformImpl {
+private:
+  llvm::Optional<bool> EnableInterleaving;
+  int InterleaveCount;
+
+  LoopInterleavingTransform(SourceRange Loc,
+                            llvm::Optional<bool> EnableInterleaving,
+                            int InterleaveCount)
+      : TransformImpl(LoopInterleavingKind, Loc, false),
+        EnableInterleaving(EnableInterleaving),
+        InterleaveCount(InterleaveCount) {}
+
+public:
+  static bool classof(const LoopInterleavingTransform *Trans) { return true; }
+  static bool classof(const Transform *Trans) {
+    return Trans->getKind() == LoopInterleavingKind;
+  }
+
+  static LoopInterleavingTransform *
+  Create(SourceRange Loc, llvm::Optional<bool> EnableInterleaving,
+         int InterleaveCount) {
+    assert(EnableInterleaving.getValueOr(true));
+    return new LoopInterleavingTransform(Loc, EnableInterleaving,
+                                         InterleaveCount);
+  }
+
+  int getNumInputs() const { return 1; }
+  int getNumFollowups() const { return 3; }
+  enum Input {
+    InputToVectorize,
+  };
+  enum Followup { FollowupAll, FollowupVectorized, FollowupEpilogue };
+
+  llvm::Optional<bool> isInterleavingEnabled() const {
+    return EnableInterleaving;
+  }
+
+  int getInterleaveCount() const { return InterleaveCount; }
+};
+
+class LoopVectorizationInterleavingTransform final : public TransformImpl {
+private:
+  bool AssumeSafety;
+  llvm::Optional<bool> EnableVectorization;
+  llvm::Optional<bool> EnableInterleaving;
+  int VectorizeWidth;
+  llvm::Optional<bool> VectorizePredicateEnable;
+  int InterleaveCount;
+
+  LoopVectorizationInterleavingTransform(
+      SourceRange Loc, bool IsLegacy, bool AssumeSafety,
+      llvm::Optional<bool> EnableVectorization,
+      llvm::Optional<bool> EnableInterleaving, int VectorizeWidth,
+      llvm::Optional<bool> VectorizePredicateEnable, int InterleaveCount)
+      : TransformImpl(LoopVectorizationInterleavingKind, Loc, IsLegacy),
+        AssumeSafety(AssumeSafety), EnableVectorization(EnableVectorization),
+        EnableInterleaving(EnableInterleaving), VectorizeWidth(VectorizeWidth),
+        VectorizePredicateEnable(VectorizePredicateEnable),
+        InterleaveCount(InterleaveCount) {}
+
+public:
+  static bool classof(const LoopVectorizationInterleavingTransform *Trans) {
+    return true;
+  }
+  static bool classof(const Transform *Trans) {
+    return Trans->getKind() == LoopVectorizationInterleavingKind;
+  }
+
+  static LoopVectorizationInterleavingTransform *
+  create(SourceRange Loc, bool Legacy, bool AssumeSafety,
+         llvm::Optional<bool> EnableVectorization,
+         llvm::Optional<bool> EnableInterleaving, int VectorizeWidth,
+         llvm::Optional<bool> VectorizePredicateEnable, int InterleaveCount) {
+    assert(EnableVectorization.getValueOr(true) ||
+           EnableInterleaving.getValueOr(true));
+    return new LoopVectorizationInterleavingTransform(
+        Loc, Legacy, AssumeSafety, EnableVectorization, EnableInterleaving,
+        VectorizeWidth, VectorizePredicateEnable, InterleaveCount);
+  }
+
+  int getNumInputs() const { return 1; }
+  int getNumFollowups() const { return 3; }
+  enum Input {
+    InputToVectorize,
+  };
+  enum Followup { FollowupAll, FollowupVectorized, FollowupEpilogue };
+
+  bool isAssumeSafety() const { return AssumeSafety; }
+  llvm::Optional<bool> isVectorizationEnabled() const {
+    return EnableVectorization;
+  }
+  llvm::Optional<bool> isInterleavingEnabled() const {
+    return EnableInterleaving;
+  }
+
+  int getWidth() const { return VectorizeWidth; }
+  llvm::Optional<bool> isPredicateEnabled() const {
+    return VectorizePredicateEnable;
+  }
+  int getInterleaveCount() const { return InterleaveCount; }
+};
+
+class LoopUnrollingTransform final : public TransformImpl {
+private:
+  bool ImplicitEnable;
+  bool ExplicitEnable;
+  int64_t Factor;
+
+  LoopUnrollingTransform(SourceRange Loc, bool IsLegacy, bool ImplicitEnable,
+                         bool ExplicitEnable, int Factor)
+      : TransformImpl(LoopUnrollingKind, Loc, IsLegacy),
+        ImplicitEnable(ImplicitEnable), ExplicitEnable(ExplicitEnable),
+        Factor(Factor) {}
+
+public:
+  static bool classof(const LoopUnrollingTransform *Trans) { return true; }
+  static bool classof(const Transform *Trans) {
+    return Trans->getKind() == LoopUnrollingKind;
+  }
+
+  static LoopUnrollingTransform *create(SourceRange Loc, bool Legacy,
+                                        bool ImplicitEnable,
+                                        bool ExplicitEnable) {
+    return new LoopUnrollingTransform(Loc, Legacy, ImplicitEnable,
+                                      ExplicitEnable, 0);
+  }
+  static LoopUnrollingTransform *createFull(SourceRange Loc, bool Legacy,
+                                            bool ImplicitEnable,
+                                            bool ExplicitEnable) {
+    return new LoopUnrollingTransform(Loc, Legacy, ImplicitEnable,
+                                      ExplicitEnable, -1);
+  }
+  static LoopUnrollingTransform *createPartial(SourceRange Loc, bool Legacy,
+                                               bool ImplicitEnable,
+                                               bool ExplicitEnable,
+                                               int Factor) {
+    return new LoopUnrollingTransform(Loc, Legacy, ImplicitEnable,
+                                      ExplicitEnable, Factor);
+  }
+
+  int getNumInputs() const { return 1; }
+  int getNumFollowups() const { return 3; }
+  enum Input {
+    InputToUnroll,
+  };
+  enum Followup {
+    FollowupAll,      // if not full
+    FollowupUnrolled, // if not full
+    FollowupRemainder
+  };
+
+  bool hasFollowupRole(int i) { return isFull(); }
+  int getDefaultSuccessor() const {
+    return isLegacy() ? FollowupAll : FollowupUnrolled;
+  }
+
+  bool isImplicitEnable() const { return ImplicitEnable; }
+
+  bool isExplicitEnable() const { return ExplicitEnable; }
+
+  int getFactor() const { return Factor; }
+
+  bool isFull() const { return Factor == -1; }
+};
+
+class LoopUnrollAndJamTransform final : public TransformImpl {
+private:
+  bool ExplicitEnable;
+  int Factor;
+
+  LoopUnrollAndJamTransform(SourceRange Loc, bool IsLegacy, bool ExplicitEnable,
+                            int Factor)
+      : TransformImpl(LoopUnrollAndJamKind, Loc, IsLegacy),
+        ExplicitEnable(ExplicitEnable), Factor(Factor) {}
+
+public:
+  static bool classof(const LoopUnrollAndJamTransform *Trans) { return true; }
+  static bool classof(const Transform *Trans) {
+    return Trans->getKind() == LoopUnrollAndJamKind;
+  }
+
+  static LoopUnrollAndJamTransform *create(SourceRange Loc, bool Legacy,
+                                           bool ExplicitEnable) {
+    return new LoopUnrollAndJamTransform(Loc, Legacy, ExplicitEnable, 0);
+  }
+  static LoopUnrollAndJamTransform *createFull(SourceRange Loc, bool Legacy,
+                                               bool ExplicitEnable) {
+    return new LoopUnrollAndJamTransform(Loc, Legacy, ExplicitEnable, -1);
+  }
+  static LoopUnrollAndJamTransform *
+  createPartial(SourceRange Loc, bool Legacy, bool ExplicitEnable, int Factor) {
+    return new LoopUnrollAndJamTransform(Loc, Legacy, ExplicitEnable, Factor);
+  }
+
+  int getNumInputs() const { return 1; }
+  int getNumFollowups() const { return 3; }
+  enum Input {
+    InputOuter,
+    InputInner,
+  };
+  enum Followup { FollowupAll, FollowupOuter, FollowupInner };
+
+  bool isExplicitEnable() const { return ExplicitEnable; }
+
+  int getFactor() const {
+    assert(Factor >= 0);
+    return Factor;
+  }
+
+  bool isFull() const { return Factor == -1; }
+};
+
+class LoopPipeliningTransform final : public TransformImpl {
+private:
+  int InitiationInterval;
+
+  LoopPipeliningTransform(SourceRange Loc, int InitiationInterval)
+      : TransformImpl(LoopPipeliningKind, Loc, true),
+        InitiationInterval(InitiationInterval) {}
+
+public:
+  static bool classof(const LoopPipeliningTransform *Trans) { return true; }
+  static bool classof(const Transform *Trans) {
+    return Trans->getKind() == LoopPipeliningKind;
+  }
+
+  static LoopPipeliningTransform *create(SourceRange Loc,
+                                         int InitiationInterval) {
+    return new LoopPipeliningTransform(Loc, InitiationInterval);
+  }
+
+  int getNumInputs() const { return 1; }
+  int getNumFollowups() const { return 0; }
+  enum Input {
+    InputToPipeline,
+  };
+
+  int getInitiationInterval() const { return InitiationInterval; }
+};
+
+class LoopAssumeParallelTransform final : public TransformImpl {
+private:
+  LoopAssumeParallelTransform(SourceRange Loc)
+      : TransformImpl(LoopAssumeParallelKind, Loc, false) {}
+
+public:
+  static bool classof(const LoopAssumeParallelTransform *Trans) { return true; }
+  static bool classof(const Transform *Trans) {
+    return Trans->getKind() == LoopAssumeParallelKind;
+  }
+
+  static LoopAssumeParallelTransform *create(SourceRange Loc) {
+    return new LoopAssumeParallelTransform(Loc);
+  }
+
+  int getNumInputs() const { return 1; }
+  int getNumFollowups() const { return 1; }
+  enum Input {
+    InputParallel,
+  };
+  enum Followup {
+    FollowupParallel,
+  };
 };
 
 } // namespace clang
 #endif /* LLVM_CLANG_AST_TRANSFORM_H */

include/clang/Analysis/AnalysisTransform.h

+//===--- AnalysisTransform.h -----------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//  Applies code transformations
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_ANALYSIS_ANALYSISTRANSFORM_H
+#define LLVM_CLANG_ANALYSIS_ANALYSISTRANSFORM_H
+
+#include "clang/AST/OpenMPClause.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/AST/Stmt.h"
+#include "clang/Basic/DiagnosticSema.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace clang {
+template <typename Derived, typename NodeTy> class TransformedTreeBuilder;
+
+/// Represents an input of a code representation.
+/// Current can reference the input code only by the AST node, but in the future
+/// loops can also given identifiers to reference them.
+class TransformInput {
+  const Stmt *StmtInput = nullptr;
+
+  TransformInput(const Stmt *StmtInput) : StmtInput(StmtInput) {}
+
+public:
+  TransformInput() {}
+
+  static TransformInput createByStmt(const Stmt *StmtInput) {
+    assert(StmtInput);
+    return TransformInput(StmtInput);
+  }
+
+  bool isByStmt() const { return StmtInput; }
+
+  const Stmt *getStmtInput() const { return StmtInput; }
+};
+
+/// Represents a transformation together with the input loops.
+/// in the future it will also identify the generated loop.
+struct NodeTransform {
+  Transform *Trans = nullptr;
+  llvm::SmallVector<TransformInput, 2> Inputs;
+
+  NodeTransform() {}
+  NodeTransform(Transform *Trans, TransformInput TopLevelInput) : Trans(Trans) {
+    assert(Trans->getNumInputs() >= 1);
+
+    Inputs.resize(Trans->getNumInputs());
+    setInput(0, TopLevelInput);
+  };
+
+  void setInput(int Idx, TransformInput Input) { Inputs[Idx] = Input; }
+};
+
+/// This class represents a loop in a loop nest to which transformations are
+/// applied to. It is intended to be instantiated for it specific purpose, that
+/// is SemaTransformedTree for semantic analysis (consistency warnings and
+/// errors) and CGTransformedTree for emitting IR.
+template <typename Derived> class TransformedTree {
+  template <typename, typename> friend class TransformedTreeBuilder;
+  using NodeTy = Derived;
+
+  Derived &getDerived() { return *static_cast<Derived *>(this); }
+  const Derived &getDerived() const {
+    return *static_cast<const Derived *>(this);
+  }
+
+protected:
+  /// Is this the root node of the loop hierarchy?
+  bool IsRoot = false;
+
+  /// Nested loops.
+  llvm::SmallVector<Derived *, 2> Subloops;
+
+  /// Origin of this loop.
+  /// @{
+
+  /// If not the result of the transformation, this is the loop statement that
+  /// this node represents.
+  Stmt *Original;
+
+  Derived *BasedOn;
+  int FollowupRole;
+  int Stage;
+
+  /// @}
+
+  /// Things applied to this loop.
+  /// @{
+
+  /// If this is the primary transformation input.
+  Transform *TransformedBy = nullptr;
+
+  // Primary/secondary transformation input
+  Derived *PrimaryInput = nullptr;
+
+  llvm::SmallVector<Derived *, 4> Followups;
+  Derived *Successor = nullptr;
+  int InputRole = -1;
+
+  bool IsParallel = false;
+  /// @}
+
+protected:
+  TransformedTree(llvm::ArrayRef<Derived *> SubLoops, Derived *BasedOn,
+                  clang::Stmt *Original, int FollowupRole, int Stage)
+      : Subloops(SubLoops.begin(), SubLoops.end()), Original(Original),
+        BasedOn(BasedOn), FollowupRole(FollowupRole), Stage(Stage) {}
+
+public:
+  ArrayRef<Derived *> getSubLoops() const { return Subloops; }
+
+  Derived *getPrimaryInput() const { return PrimaryInput; }
+  Transform *getTransformedBy() const { return TransformedBy; }
+
+  Stmt *getOriginal() const { return Original; }
+  Stmt *getInheritedOriginal() const {
+    if (Original)
+      return Original;
+    if (BasedOn)
+      return BasedOn->getInheritedOriginal();
+    return nullptr;
+  }
+
+  Derived *getBasedOn() const { return BasedOn; }
+
+  void markParallel() { IsParallel = true; }
+  bool isParallel() const { return IsParallel; }
+
+  bool isRoot() const { return IsRoot; }
+
+  int getStage() const { return Stage; }
+
+  Derived *getSuccessor() { return Successor; }
+
+  Derived *getLatestSuccessor() {
+    // If the loop is not being consumed, this is the latest successor.
+    if (!isTransformationInput())
+      return &getDerived();
+    // It is possible for a loop consumed into a non-loop, such that it has no
+    // successor.
+    if (!Successor)
+      return nullptr;
+    return Successor->getLatestSuccessor();
+  }
+
+  const Derived *getLatestSuccessor() const {
+    return const_cast<Derived *>(this)->getLatestSuccessor();
+  }
+
+  bool isOriginal() const { return Original; }
+
+  bool isTransformationInput() const {
+    bool Result = InputRole >= 0;
+    assert(Result == (PrimaryInput != nullptr));
+    return Result;
+  }
+
+  bool isTransformationFollowup() const {
+    bool Result = FollowupRole >= 0;
+    assert(Result == (BasedOn != nullptr));
+    return Result;
+  }
+
+  bool isPrimaryInput() const {
+    bool Result = (InputRole == 0);
+    assert(Result == (PrimaryInput == this));
+    return PrimaryInput == this;
+  }
+
+  void applyTransformation(Transform *Trans,
+                           llvm::ArrayRef<Derived *> Followups,
+                           Derived *Successor) {
+    assert(!isTransformationInput());
+
+    this->TransformedBy = Trans;
+    this->Followups.insert(this->Followups.end(), Followups.begin(),
+                           Followups.end());
+    this->Successor = Successor;
+    this->PrimaryInput = &getDerived();
+    this->InputRole = 0; // for primary
+
+#ifndef NDEBUG
+    assert(isTransformationInput() && isPrimaryInput());
+    for (NodeTy *S : Followups) {
+      assert(S->BasedOn == &getDerived());
+    }
+#endif
+  }
+
+  void applySuccessors(Derived *PrimaryInput, int InputRole,
+                       llvm::ArrayRef<Derived *> Followups,
+                       Derived *Successor) {
+    assert(!isTransformationInput());
+    assert(InputRole > 0);
+
+    this->PrimaryInput = PrimaryInput;
+    this->Followups.insert(this->Followups.end(), Followups.begin(),
+                           Followups.end());
+    this->Successor = Successor;
+    this->InputRole = InputRole;
+
+#ifndef NDEBUG
+    assert(isTransformationInput() && !isPrimaryInput());
+    for (NodeTy *S : Followups) {
+      assert(S->BasedOn == &getDerived());
+    }
+#endif
+  }
+};
+
+/// Constructs a loop nest from source and applies transformations on it.
+template <typename Derived, typename NodeTy> class TransformedTreeBuilder {
+  using BuilderTy = Derived;
+
+  Derived &getDerived() { return *static_cast<Derived *>(this); }
+  const Derived &getDerived() const {
+    return *static_cast<const Derived *>(this);
+  }
+
+  ASTContext &ASTCtx;
+  llvm::SmallVectorImpl<NodeTy *> &AllNodes;
+
+private:
+  /// Build the original loop nest hierarchy from the AST.
+  void buildPhysicalLoopTree(Stmt *S, SmallVectorImpl<NodeTy *> &SubLoops,
+                             llvm::DenseMap<Stmt *, NodeTy *> &StmtToTree) {
+    if (!S)
+      return;
+
+    Stmt *Body;
+    switch (S->getStmtClass()) {
+    case Stmt::ForStmtClass:
+      Body = cast<ForStmt>(S)->getBody();
+      break;
+    case Stmt::WhileStmtClass:
+      Body = cast<WhileStmt>(S)->getBody();
+      break;
+    case Stmt::DoStmtClass:
+      Body = cast<DoStmt>(S)->getBody();
+      break;
+    case Stmt::CXXForRangeStmtClass:
+      Body = cast<CXXForRangeStmt>(S)->getBody();
+      break;
+    case Stmt::CapturedStmtClass:
+      buildPhysicalLoopTree(cast<CapturedStmt>(S)->getCapturedStmt(), SubLoops,
+                            StmtToTree);
+      return;
+    case Expr::LambdaExprClass:
+      // Call to getBody materializes its body, children() (which is called in
+      // the default case) does not.
+      buildPhysicalLoopTree(cast<LambdaExpr>(S)->getBody(), SubLoops,
+                            StmtToTree);
+      return;
+    case Expr::BlockExprClass:
+      buildPhysicalLoopTree(cast<BlockExpr>(S)->getBody(), SubLoops,
+                            StmtToTree);
+      return;
+    default:
+      if (auto *O = dyn_cast<OMPExecutableDirective>(S)) {
+        if (!O->hasAssociatedStmt())
+          return;
+        Stmt *Associated = O->getAssociatedStmt();
+        buildPhysicalLoopTree(Associated, SubLoops, StmtToTree);
+        return;
+      }
+
+      for (Stmt *Child : S->children())
+        buildPhysicalLoopTree(Child, SubLoops, StmtToTree);
+
+      return;
+    }
+
+    SmallVector<NodeTy *, 8> SubSubLoops;
+    buildPhysicalLoopTree(Body, SubSubLoops, StmtToTree);
+
+    NodeTy *L = getDerived().createPhysical(SubSubLoops, S);
+    SubLoops.push_back(L);
+    assert(StmtToTree.count(S) == 0);
+    StmtToTree[S] = L;
+
+    getDerived().applyOriginal(L);
+  }
+
+  /// Collect all loop transformations in the function's AST.
+  class CollectTransformationsVisitor
+      : public RecursiveASTVisitor<CollectTransformationsVisitor> {
+
+    Derived &Builder;
+    llvm::DenseMap<Stmt *, NodeTy *> &StmtToTree;
+
+  public:
+    CollectTransformationsVisitor(Derived &Builder,
+                                  llvm::DenseMap<Stmt *, NodeTy *> &StmtToTree)
+        : Builder(Builder), StmtToTree(StmtToTree) {}
+
+    /// Transformations collected so far.
+    llvm::SmallVector<NodeTransform, 16> Transforms;
+
+    bool shouldTraversePostOrder() const { return true; }
+
+    /// Read and apply LoopHint (#pragma clang loop) attributes.
+    void applyAttributed(const Stmt *S, ArrayRef<const Attr *> Attrs,
+                         NodeTy *L) {
+
+      /// State of loop vectorization or unrolling.
+      enum LVEnableState { Unspecified, Enable, Disable, Full };
+
+      /// Value for llvm.loop.vectorize.enable metadata.
+      LVEnableState VectorizeEnable = Unspecified;
+      bool VectorizeAssumeSafety = false;
+
+      /// Value for llvm.loop.unroll.* metadata (enable, disable, or full).
+      LVEnableState UnrollEnable = Unspecified;
+
+      /// Value for llvm.loop.unroll_and_jam.* metadata (enable, disable, or
+      /// full).
+      LVEnableState UnrollAndJamEnable = Unspecified;
+
+      /// Value for llvm.loop.vectorize.predicate metadata
+      LVEnableState VectorizePredicateEnable = Unspecified;
+
+      /// Value for llvm.loop.vectorize.width metadata.
+      unsigned VectorizeWidth = 0;
+
+      /// Value for llvm.loop.interleave.count metadata.
+      unsigned InterleaveCount = 0;
+
+      /// llvm.unroll.
+      unsigned UnrollCount = 0;
+
+      /// llvm.unroll.
+      unsigned UnrollAndJamCount = 0;
+
+      /// Value for llvm.loop.distribute.enable metadata.
+      LVEnableState DistributeEnable = Unspecified;
+
+      /// Value for llvm.loop.pipeline.disable metadata.
+      bool PipelineDisabled = false;
+
+      /// Value for llvm.loop.pipeline.iicount metadata.
+      unsigned PipelineInitiationInterval = 0;
+
+      SourceLocation DistLoc;
+      SourceLocation VecLoc;
+      SourceLocation UnrollLoc;
+      SourceLocation UnrollAndJamLoc;
+      SourceLocation PipelineLoc;
+      for (const Attr *Attr : Attrs) {
+        const LoopHintAttr *LH = dyn_cast<LoopHintAttr>(Attr);
+        const OpenCLUnrollHintAttr *OpenCLHint =
+            dyn_cast<OpenCLUnrollHintAttr>(Attr);
+
+        // Skip non loop hint attributes
+        if (!LH && !OpenCLHint) {
+          continue;
+        }
+
+        LoopHintAttr::OptionType Option = LoopHintAttr::Unroll;
+        LoopHintAttr::LoopHintState State = LoopHintAttr::Disable;
+        unsigned ValueInt = 1;
+        // Translate opencl_unroll_hint attribute argument to
+        // equivalent LoopHintAttr enums.
+        // OpenCL v2.0 s6.11.5:
+        // 0 - enable unroll (no argument).
+        // 1 - disable unroll.
+        // other positive integer n - unroll by n.
+        if (OpenCLHint) {
+          ValueInt = OpenCLHint->getUnrollHint();
+          if (ValueInt == 0) {
+            State = LoopHintAttr::Enable;
+          } else if (ValueInt != 1) {
+            Option = LoopHintAttr::UnrollCount;
+            State = LoopHintAttr::Numeric;
+          }
+        } else if (LH) {
+          Expr *ValueExpr = LH->getValue();
+          if (ValueExpr) {
+            if (ValueExpr->isValueDependent())
+              continue; // Ignore this attribute until it is instantiated.
+            llvm::APSInt ValueAPS =
+                ValueExpr->EvaluateKnownConstInt(Builder.ASTCtx);
+            ValueInt = ValueAPS.getSExtValue();
+          }
+
+          Option = LH->getOption();
+          State = LH->getState();
+        }
+
+        switch (Option) {
+        case LoopHintAttr::Vectorize:
+        case LoopHintAttr::Interleave:
+        case LoopHintAttr::VectorizeWidth:
+        case LoopHintAttr::InterleaveCount:
+        case LoopHintAttr::VectorizePredicate:
+          VecLoc = Attr->getLocation();
+          break;
+        case LoopHintAttr::Unroll:
+        case LoopHintAttr::UnrollCount:
+          UnrollLoc = Attr->getLocation();
+          break;
+        case LoopHintAttr::UnrollAndJam:
+        case LoopHintAttr::UnrollAndJamCount:
+          UnrollAndJamLoc = Attr->getLocation();
+          break;
+        case LoopHintAttr::Distribute:
+          DistLoc = Attr->getLocation();
+          break;
+
+        case LoopHintAttr::PipelineDisabled:
+        case LoopHintAttr::PipelineInitiationInterval:
+          PipelineLoc = Attr->getLocation();
+          break;
+        }
+
+        switch (State) {
+        case LoopHintAttr::Disable:
+          switch (Option) {
+          case LoopHintAttr::Vectorize:
+            // Disable vectorization by specifying a width of 1.
+            VectorizeWidth = 1;
+            break;
+          case LoopHintAttr::Interleave:
+            // Disable interleaving by specifying a count of 1.
+            InterleaveCount = 1;
+            break;
+          case LoopHintAttr::Unroll:
+            UnrollEnable = Disable;
+            break;
+          case LoopHintAttr::UnrollAndJam:
+            UnrollAndJamEnable = Disable;
+            break;
+          case LoopHintAttr::VectorizePredicate:
+            VectorizePredicateEnable = Disable;
+            break;
+          case LoopHintAttr::Distribute:
+            DistributeEnable = Disable;
+            break;
+          case LoopHintAttr::PipelineDisabled:
+            PipelineDisabled = true;
+            break;
+          case LoopHintAttr::UnrollCount:
+          case LoopHintAttr::UnrollAndJamCount:
+          case LoopHintAttr::VectorizeWidth:
+          case LoopHintAttr::InterleaveCount:
+          case LoopHintAttr::PipelineInitiationInterval:
+            llvm_unreachable("Options cannot be disabled.");
+            break;
+          }
+          break;
+        case LoopHintAttr::Enable:
+          switch (Option) {
+          case LoopHintAttr::Vectorize:
+          case LoopHintAttr::Interleave:
+            VectorizeEnable = Enable;
+            break;
+          case LoopHintAttr::Unroll:
+            UnrollEnable = Enable;
+            break;
+          case LoopHintAttr::UnrollAndJam:
+            UnrollAndJamEnable = Enable;
+            break;
+          case LoopHintAttr::VectorizePredicate:
+            VectorizePredicateEnable = Enable;
+            break;
+          case LoopHintAttr::Distribute:
+            DistributeEnable = Enable;
+            break;
+          case LoopHintAttr::UnrollCount:
+          case LoopHintAttr::UnrollAndJamCount:
+          case LoopHintAttr::VectorizeWidth:
+          case LoopHintAttr::InterleaveCount:
+          case LoopHintAttr::PipelineDisabled:
+          case LoopHintAttr::PipelineInitiationInterval:
+            llvm_unreachable("Options cannot enabled.");
+            break;
+          }
+          break;
+        case LoopHintAttr::AssumeSafety:
+          switch (Option) {
+          case LoopHintAttr::Vectorize:
+          case LoopHintAttr::Interleave:
+            // Apply "llvm.mem.parallel_loop_access" metadata to load/stores.
+            VectorizeEnable = Enable;
+            VectorizeAssumeSafety = true;
+            break;
+          case LoopHintAttr::Unroll:
+          case LoopHintAttr::UnrollAndJam:
+          case LoopHintAttr::VectorizePredicate:
+          case LoopHintAttr::UnrollCount:
+          case LoopHintAttr::UnrollAndJamCount:
+          case LoopHintAttr::VectorizeWidth:
+          case LoopHintAttr::InterleaveCount:
+          case LoopHintAttr::Distribute:
+          case LoopHintAttr::PipelineDisabled:
+          case LoopHintAttr::PipelineInitiationInterval:
+            llvm_unreachable("Options cannot be used to assume mem safety.");
+            break;
+          }
+          break;
+        case LoopHintAttr::Full:
+          switch (Option) {
+          case LoopHintAttr::Unroll:
+            UnrollEnable = Full;
+            break;
+          case LoopHintAttr::UnrollAndJam:
+            UnrollAndJamEnable = Full;
+            break;
+          case LoopHintAttr::Vectorize:
+          case LoopHintAttr::Interleave:
+          case LoopHintAttr::UnrollCount:
+          case LoopHintAttr::UnrollAndJamCount:
+          case LoopHintAttr::VectorizeWidth:
+          case LoopHintAttr::InterleaveCount:
+          case LoopHintAttr::Distribute:
+          case LoopHintAttr::PipelineDisabled:
+          case LoopHintAttr::PipelineInitiationInterval:
+          case LoopHintAttr::VectorizePredicate:
+            llvm_unreachable("Options cannot be used with 'full' hint.");
+            break;
+          }
+          break;
+        case LoopHintAttr::Numeric:
+          switch (Option) {
+          case LoopHintAttr::VectorizeWidth:
+            VectorizeWidth = ValueInt;
+            break;
+          case LoopHintAttr::InterleaveCount:
+            InterleaveCount = ValueInt;
+            break;
+          case LoopHintAttr::UnrollCount:
+            UnrollCount = ValueInt;
+            break;
+          case LoopHintAttr::UnrollAndJamCount:
+            UnrollAndJamCount = ValueInt;
+            break;
+          case LoopHintAttr::PipelineInitiationInterval:
+            PipelineInitiationInterval = ValueInt;
+            break;
+          case LoopHintAttr::Unroll:
+          case LoopHintAttr::UnrollAndJam:
+          case LoopHintAttr::VectorizePredicate:
+          case LoopHintAttr::Vectorize:
+          case LoopHintAttr::Interleave:
+          case LoopHintAttr::Distribute:
+          case LoopHintAttr::PipelineDisabled:
+            llvm_unreachable("Options cannot be assigned a value.");
+            break;
+          }
+          break;
+        }
+      }
+
+      bool VectorizeDisabled =
+          (VectorizeEnable == Disable || VectorizeWidth == 1);
+      bool InterleaveDisabled = (InterleaveCount == 1);
+      bool VectorizeInterleaveDisabled =
+          VectorizeDisabled && InterleaveDisabled && !VectorizeAssumeSafety;
+
+      if (UnrollEnable == Disable)
+        Builder.disableUnroll(L);
+
+      if (UnrollAndJamEnable == Disable)
+        Builder.disableUnrollAndJam(L);
+
+      if (DistributeEnable == Disable)
+        Builder.disableDistribution(L);
+
+      // If the LoopVectorize pass is completely disabled (ie. vectorize and
+      // interleave).
+      if (VectorizeInterleaveDisabled)
+        Builder.disableVectorizeInterleave(L);
+
+      if (PipelineDisabled)
+        Builder.disablePipelining(L);
+
+      if (UnrollEnable == Full) {
+        Transform *Trans =
+            LoopUnrollingTransform::createFull(UnrollLoc, true, false, true);
+        Transforms.emplace_back(Trans, TransformInput::createByStmt(S));
+      }
+
+      if (DistributeEnable == Enable) {
+        auto *Trans = LoopDistributionTransform::create(DistLoc, true);
+        Transforms.emplace_back(Trans, TransformInput::createByStmt(S));
+      }
+
+      if ((VectorizeEnable == Enable || VectorizeWidth > 0 ||
+           VectorizePredicateEnable != Unspecified || InterleaveCount > 0) &&
+          !VectorizeInterleaveDisabled) {
+        auto *Trans = LoopVectorizationInterleavingTransform::create(
+            VecLoc, true, VectorizeAssumeSafety,
+            VectorizeEnable != Unspecified
+                ? llvm::Optional<bool>(VectorizeEnable == Enable)
+                : None,
+            None, VectorizeWidth,
+            (VectorizePredicateEnable != Unspecified)
+                ? llvm::Optional<bool>(VectorizePredicateEnable == Enable)
+                : None,
+            InterleaveCount);
+        Transforms.emplace_back(Trans, TransformInput::createByStmt(S));
+      }
+
+      if (UnrollAndJamEnable == Enable || UnrollAndJamEnable == Full ||
+          UnrollAndJamCount > 0) {
+        LoopUnrollAndJamTransform *Trans;
+        if (UnrollAndJamEnable == Full)
+          Trans = LoopUnrollAndJamTransform::createFull(UnrollAndJamLoc, true,
+                                                        true);
+        else
+          Trans = LoopUnrollAndJamTransform::createPartial(
+              UnrollAndJamLoc, true, UnrollAndJamEnable == Enable,
+              UnrollAndJamCount);
+        Transforms.emplace_back(Trans, TransformInput::createByStmt(S));
+      }
+
+      if (UnrollEnable != Full && (UnrollEnable == Enable || UnrollCount > 0)) {
+        auto *Trans = LoopUnrollingTransform::createPartial(
+            UnrollLoc, true, false, UnrollEnable == Enable, UnrollCount);
+        Transforms.emplace_back(Trans, TransformInput::createByStmt(S));
+      }
+
+      if (PipelineInitiationInterval > 0) {
+        auto *Trans = LoopPipeliningTransform::create(
+            PipelineLoc, PipelineInitiationInterval);
+        Transforms.emplace_back(Trans, TransformInput::createByStmt(S));
+      }
+    }
+
+    bool VisitAttributedStmt(const AttributedStmt *S) {
+      const Stmt *LoopStmt = getAssociatedLoop(S);
+
+      // Not every attributed statement is associated with a loop.
+      if (!LoopStmt)
+        return true;
+
+      NodeTy *Node = StmtToTree.lookup(LoopStmt);
+      assert(Node && "We should have created a node for ever loop");
+      applyAttributed(LoopStmt, S->getAttrs(), Node);
+      return true;
+    }
+
+    bool
+    VisitTransformExecutableDirective(const TransformExecutableDirective *S) {
+      // Can happen in semantic analysis in non-instantiated templates.
+      if (!S->getTransform())
+        return false;
+
+      const Stmt *TheLoop = getAssociatedLoop(S->getAssociated());
+      Transforms.emplace_back(S->getTransform(),
+                              TransformInput::createByStmt(TheLoop));
+      return true;
+    }
+
+    bool HandleOMPLoopClauses(OMPLoopDirective *Directive, bool HasTaskloop,
+                              bool HasFor, bool HasSimd) {
+      const Stmt *TopLevel = getAssociatedLoop(Directive);
+
+      bool IsMonotonic = true;
+      if (HasFor) {
+        if (auto *ScheduleClause =
+                Directive->getSingleClause<OMPScheduleClause>()) {
+          OpenMPScheduleClauseKind Schedule = ScheduleClause->getScheduleKind();
+          if (Schedule != OMPC_SCHEDULE_unknown &&
+              Schedule != OMPC_SCHEDULE_static)
+            IsMonotonic = false;
+
+          if (ScheduleClause->getFirstScheduleModifier() ==
+              OMPC_SCHEDULE_MODIFIER_monotonic)
+            IsMonotonic = true;
+          if (ScheduleClause->getSecondScheduleModifier() ==
+              OMPC_SCHEDULE_MODIFIER_monotonic)
+            IsMonotonic = true;
+        }
+
+        if (auto *OrderedClause =
+                Directive->getSingleClause<OMPOrderedClause>()) {
+          if (!OrderedClause->getNumForLoops())
+            IsMonotonic = true;
+        }
+      }
+
+      if (HasTaskloop)
+        IsMonotonic = false;
+
+      int64_t SimdWidth = 0;
+      bool SimdImplicitParallel = false;
+      if (HasSimd) {
+        if (!HasFor)
+          SimdImplicitParallel = true;
+
+        if (auto *LenClause = Directive->getSingleClause<OMPSafelenClause>()) {
+          auto SafelenExpr = LenClause->getSafelen();
+          if (!SafelenExpr->isValueDependent() &&
+              SafelenExpr->isEvaluatable(Builder.ASTCtx)) {
+            llvm::APSInt ValueAPS =
+                SafelenExpr->EvaluateKnownConstInt(Builder.ASTCtx);
+            SimdWidth = ValueAPS.getSExtValue();
+          }
+
+          // In presence of finite 'safelen', it may be unsafe to mark all
+          // the memory instructions parallel, because loop-carried
+          // dependences of 'safelen' iterations are possible.
+          SimdImplicitParallel = false;
+          IsMonotonic = true;
+        }
+
+        if (auto LenClause = Directive->getSingleClause<OMPSimdlenClause>()) {
+          auto SimdlenExpr = LenClause->getSimdlen();
+          if (!SimdlenExpr->isValueDependent() &&
+              SimdlenExpr->isEvaluatable(Builder.ASTCtx)) {
+            llvm::APSInt ValueAPS =
+                SimdlenExpr->EvaluateKnownConstInt(Builder.ASTCtx);
+            SimdWidth = ValueAPS.getSExtValue();
+          }
+        }
+      }
+
+      bool IsImplicitParallel = !IsMonotonic || SimdImplicitParallel;
+
+      if (HasSimd) {
+        auto *Trans = LoopVectorizationInterleavingTransform::create(
+            Directive->getSourceRange(), true, IsImplicitParallel, true, None,
+            SimdWidth, None, 0);
+        Transforms.emplace_back(Trans, TransformInput::createByStmt(TopLevel));
+      } else if (IsImplicitParallel) {
+        auto *Assume =
+            LoopAssumeParallelTransform::create(Directive->getSourceRange());
+        Transforms.emplace_back(Assume, TransformInput::createByStmt(TopLevel));
+      }
+
+      return true;
+    }
+
+    bool VisitOMPForDirective(OMPForDirective *For) {
+      return HandleOMPLoopClauses(For, false, true, false);
+    }
+
+    bool VisitOMPDistributeParallelForDirective(
+        OMPDistributeParallelForDirective *L) {
+      return HandleOMPLoopClauses(L, false, true, false);
+    }
+
+    bool VisitOMPTeamsDistributeParallelForDirective(
+        OMPTeamsDistributeParallelForDirective *L) {
+      return HandleOMPLoopClauses(L, false, true, false);
+    }
+
+    bool VisitOMPTargetTeamsDistributeParallelForDirective(
+        OMPTargetTeamsDistributeParallelForDirective *L) {
+      return HandleOMPLoopClauses(L, false, true, false);
+    }
+
+    bool VisitOMPSimdDirective(OMPLoopDirective *Simd) {
+      return HandleOMPLoopClauses(Simd, false, false, true);
+    }
+
+    bool VisitOMPForSimdDirective(OMPForSimdDirective *ForSimd) {
+      return HandleOMPLoopClauses(ForSimd, false, true, true);
+    }
+
+    bool
+    VisitOMPParallelForSimdDirective(OMPParallelForSimdDirective *ForSimd) {
+      return HandleOMPLoopClauses(ForSimd, false, true, true);
+    }
+
+    bool VisitOMPDistributeSimdDirective(
+        OMPDistributeSimdDirective *DistributeSimd) {
+      return HandleOMPLoopClauses(DistributeSimd, false, false, true);
+    }
+
+    bool VisitOMPDistributeParallelForSimdDirective(
+        OMPDistributeParallelForSimdDirective *DistributeSimd) {
+      return HandleOMPLoopClauses(DistributeSimd, false, true, true);
+    }
+
+    bool VisitOMPTeamsDistributeSimdDirective(
+        OMPTeamsDistributeSimdDirective *TeamsDistributeSimd) {
+      return HandleOMPLoopClauses(TeamsDistributeSimd, false, false, true);
+    }
+
+    bool VisitOMPTeamsDistributeParallelForSimdDirective(
+        OMPTeamsDistributeParallelForSimdDirective
+            *TeamsDistributeParallelForSimd) {
+      return HandleOMPLoopClauses(TeamsDistributeParallelForSimd, false, true,
+                                  true);
+    }
+
+    bool VisitOMPTargetTeamsDistributeSimdDirective(
+        OMPTargetTeamsDistributeSimdDirective *TargetTeamsDistributeSimd) {
+      return HandleOMPLoopClauses(TargetTeamsDistributeSimd, false, false,
+                                  true);
+    }
+
+    bool VisitOMPTargetTeamsDistributeParallelForSimdDirective(
+        OMPTargetTeamsDistributeParallelForSimdDirective
+            *TargetTeamsDistributeParallelForSimd) {
+      return HandleOMPLoopClauses(TargetTeamsDistributeParallelForSimd, false,
+                                  true, true);
+    }
+
+    bool VisitOMPTaskLoopSimdDirective(
+        OMPTaskLoopSimdDirective *TaskLoopSimdDirective) {
+      return HandleOMPLoopClauses(TaskLoopSimdDirective, true, false, true);
+    }
+
+    bool
+    VisitOMPTargetSimdDirective(OMPTargetSimdDirective *TargetSimdDirective) {
+      return HandleOMPLoopClauses(TargetSimdDirective, false, false, true);
+    }
+
+    bool VisitOMPTargetParallelForSimdDirective(
+        OMPTargetParallelForSimdDirective *TargetParallelForSimdDirective) {
+      return HandleOMPLoopClauses(TargetParallelForSimdDirective, false, true,
+                                  true);
+    }
+  };
+
+  /// Applies collected transformations to the loop nest representation.
+  struct TransformApplicator {
+    Derived &Builder;
+    llvm::DenseMap<const Stmt *, llvm::SmallVector<NodeTransform *, 2>>
+        TransByStmt;
+
+    TransformApplicator(Derived &Builder) : Builder(Builder) {}
+
+    void addNodeTransform(NodeTransform *NT) {
+      TransformInput &TopLevelInput = NT->Inputs[0];
+      TransByStmt[TopLevelInput.getStmtInput()].push_back(NT);
+    }
+
+    void checkStageOrder(ArrayRef<NodeTy *> PrevLoops, Transform *NewTrans) {
+      int NewStage = NewTrans->getLoopPipelineStage();
+      if (NewStage == -1)
+        return;
+
+      for (auto PrevLoop : PrevLoops) {
+        auto PrevStage = PrevLoop->getStage();
+        if (PrevStage > NewStage) {
+          Builder.Diag(NewTrans->getBeginLoc(),
+                       diag::warn_sema_transform_pass_order);
+
+          // At most one warning per transformation.
+          return;
+        }
+      }
+    }
+
+    NodeTy *applyTransform(Transform *Trans, NodeTy *MainLoop) {
+      switch (Trans->getKind()) {
+      case Transform::Kind::LoopUnrollingKind:
+        return applyUnrolling(cast<LoopUnrollingTransform>(Trans), MainLoop);
+      case Transform::Kind::LoopUnrollAndJamKind:
+        return applyUnrollAndJam(cast<LoopUnrollAndJamTransform>(Trans),
+                                 MainLoop);
+      case Transform::Kind::LoopDistributionKind:
+        return applyDistribution(cast<LoopDistributionTransform>(Trans),
+                                 MainLoop);
+      case Transform::Kind::LoopVectorizationInterleavingKind:
+        return applyVectorizeInterleave(
+            cast<LoopVectorizationInterleavingTransform>(Trans), MainLoop);
+      case Transform::Kind::LoopVectorizationKind:
+        return applyVectorize(cast<LoopVectorizationTransform>(Trans),
+                              MainLoop);
+      case Transform::Kind::LoopInterleavingKind:
+        return applyInterleave(cast<LoopInterleavingTransform>(Trans),
+                               MainLoop);
+      case Transform::Kind::LoopPipeliningKind:
+        return applyPipelining(cast<LoopPipeliningTransform>(Trans), MainLoop);
+      case Transform::Kind::LoopAssumeParallelKind:
+        return applyAssumeParallel(cast<LoopAssumeParallelTransform>(Trans),
+                                   MainLoop);
+      default:
+        llvm_unreachable("unimplemented transformation");
+      }
+    }
+
+    void inheritLoopAttributes(NodeTy *Dst, NodeTy *Src, bool IsAll,
+                               bool IsSuccessor) {
+      Builder.inheritLoopAttributes(Dst, Src, IsAll, IsSuccessor);
+    }
+
+    NodeTy *applyUnrolling(LoopUnrollingTransform *Trans, NodeTy *MainLoop) {
+      checkStageOrder({MainLoop}, Trans);
+      int Stage = Trans->getLoopPipelineStage();
+
+      NodeTy *Successor = nullptr;
+      if (Trans->isFull()) {
+        // Full unrolling has no followup-loop.
+        MainLoop->applyTransformation(Trans, {}, nullptr);
+      } else {
+        NodeTy *All =
+            Builder.createFollowup(MainLoop->Subloops, MainLoop,
+                                   LoopUnrollingTransform::FollowupAll, Stage);
+        NodeTy *Unrolled = Builder.createFollowup(
+            MainLoop->Subloops, MainLoop,
+            LoopUnrollingTransform::FollowupUnrolled, Stage);
+        NodeTy *Remainder = Builder.createFollowup(
+            MainLoop->Subloops, MainLoop,
+            LoopUnrollingTransform::FollowupRemainder, Stage);
+        Successor = Trans->isLegacy() ? All : Unrolled;
+
+        inheritLoopAttributes(All, MainLoop, true, All == Successor);
+        MainLoop->applyTransformation(Trans, {All, Unrolled, Remainder},
+                                      Successor);
+      }
+
+      Builder.applyUnroll(Trans, MainLoop);
+      return Successor;
+    }
+
+    NodeTy *applyUnrollAndJam(LoopUnrollAndJamTransform *Trans,
+                              NodeTy *MainLoop) {
+      // Search for the innermost loop that is being jammed.
+      NodeTy *Cur = MainLoop;
+      NodeTy *Inner = nullptr;
+      if (Cur->Subloops.size() == 1) {
+        Inner = Cur->Subloops[0]->getLatestSuccessor();
+      } else if (!Trans->isLegacy()) {
+        Builder.Diag(Trans->getBeginLoc(),
+                     diag::err_sema_transform_unrollandjam_expect_nested_loop);
+        return nullptr;
+      }
+
+      if (!Trans->isLegacy() && !Inner) {
+        if (!Trans->isLegacy())
+          Builder.Diag(
+              Trans->getBeginLoc(),
+              diag::err_sema_transform_unrollandjam_expect_nested_loop);
+        return nullptr;
+      }
+
+      if (!Trans->isLegacy() && Inner->Subloops.size() != 0) {
+        if (!Trans->isLegacy())
+          Builder.Diag(Trans->getBeginLoc(),
+                       diag::err_sema_transform_unrollandjam_not_innermost);
+        return nullptr;
+      }
+
+      int Stage = Trans->getLoopPipelineStage();
+
+      // Having no loop to jam does not make a lot of sense, but fixes
+      // regression tests.
+      if (!Inner) {
+        checkStageOrder({MainLoop}, Trans);
+
+        NodeTy *UnrolledOuter = Builder.createFollowup(
+            {}, MainLoop, LoopUnrollAndJamTransform::FollowupOuter, Stage);
+        inheritLoopAttributes(UnrolledOuter, MainLoop, true, false);
+
+        MainLoop->applyTransformation(Trans, {UnrolledOuter}, UnrolledOuter);
+        Builder.applyUnrollAndJam(Trans, MainLoop, nullptr);
+        return UnrolledOuter;
+      }
+
+      checkStageOrder({MainLoop, Inner}, Trans);
+
+      NodeTy *TransformedInner = Builder.createFollowup(
+          Inner->Subloops, Inner, LoopUnrollAndJamTransform::FollowupInner,
+          Stage);
+      inheritLoopAttributes(TransformedInner, Inner, false, false);
+
+      // TODO: Handle full unrolling
+      NodeTy *UnrolledOuter = Builder.createFollowup(
+          {Inner}, MainLoop, LoopUnrollAndJamTransform::FollowupOuter, Stage);
+      inheritLoopAttributes(UnrolledOuter, MainLoop, false, true);
+
+      MainLoop->applyTransformation(Trans, {UnrolledOuter}, UnrolledOuter);
+      Inner->applySuccessors(MainLoop, LoopUnrollAndJamTransform::InputInner,
+                             {TransformedInner}, TransformedInner);
+
+      Builder.applyUnrollAndJam(Trans, MainLoop, Inner);
+      return UnrolledOuter;
+    }
+
+    NodeTy *applyDistribution(LoopDistributionTransform *Trans,
+                              NodeTy *MainLoop) {
+      checkStageOrder({MainLoop}, Trans);
+      int Stage = Trans->getLoopPipelineStage();
+
+      NodeTy *All =
+          Builder.createFollowup(MainLoop->Subloops, MainLoop,
+                                 LoopDistributionTransform::FollowupAll, Stage);
+      NodeTy *Successor = Trans->isLegacy() ? All : nullptr;
+      inheritLoopAttributes(All, MainLoop, true, Successor == All);
+
+      MainLoop->applyTransformation(Trans, {All}, Successor);
+      Builder.applyDistribution(Trans, MainLoop);
+      return Successor;
+    }
+
+    NodeTy *
+    applyVectorizeInterleave(LoopVectorizationInterleavingTransform *Trans,
+                             NodeTy *MainLoop) {
+      checkStageOrder({MainLoop}, Trans);
+      int Stage = Trans->getLoopPipelineStage();
+
+      NodeTy *All = Builder.createFollowup(
+          MainLoop->Subloops, MainLoop,
+          LoopVectorizationInterleavingTransform::FollowupAll, Stage);
+      NodeTy *Vectorized = Builder.createFollowup(
+          MainLoop->Subloops, MainLoop,
+          LoopVectorizationInterleavingTransform::FollowupVectorized, Stage);
+      NodeTy *Epilogue = Builder.createFollowup(
+          MainLoop->Subloops, MainLoop,
+          LoopVectorizationInterleavingTransform::FollowupEpilogue, Stage);
+
+      NodeTy *Successor = Trans->isLegacy() ? All : Vectorized;
+      if (Trans->isAssumeSafety() && !MainLoop->IsParallel) {
+        MainLoop->IsParallel = true;
+        Builder.markParallel(MainLoop);
+      }
+
+      inheritLoopAttributes(All, MainLoop, true, All == Successor);
+      MainLoop->applyTransformation(Trans, {All, Vectorized, Epilogue},
+                                    Successor);
+      Builder.applyVectorizeInterleave(Trans, MainLoop);
+      return Successor;
+    }
+
+    NodeTy *applyVectorize(LoopVectorizationTransform *Trans,
+                           NodeTy *MainLoop) {
+      auto *VecInterleaveTrans = LoopVectorizationInterleavingTransform::create(
+          Trans->getLoc(), false, false, true, false, Trans->getWidth(),
+          Trans->isPredicateEnabled(), 1);
+      return applyVectorizeInterleave(VecInterleaveTrans, MainLoop);
+    }
+
+    NodeTy *applyInterleave(LoopInterleavingTransform *Trans,
+                            NodeTy *MainLoop) {
+      auto *VecInterleaveTrans = LoopVectorizationInterleavingTransform::create(
+          Trans->getLoc(), false, false, false, true, 1, None,
+          Trans->getInterleaveCount());
+      return applyVectorizeInterleave(VecInterleaveTrans, MainLoop);
+    }
+
+    NodeTy *applyPipelining(LoopPipeliningTransform *Trans, NodeTy *MainLoop) {
+      checkStageOrder({MainLoop}, Trans);
+      MainLoop->applyTransformation(Trans, {}, nullptr);
+      Builder.applyPipelining(Trans, MainLoop);
+      return nullptr;
+    }
+
+    NodeTy *applyAssumeParallel(LoopAssumeParallelTransform *Assumption,
+                                NodeTy *MainLoop) {
+      if (MainLoop->isParallel())
+        return MainLoop;
+
+      MainLoop->IsParallel = true;
+      Builder.markParallel(MainLoop);
+
+      return MainLoop;
+    }
+
+    void applyOne(NodeTy *L, NodeTransform *NT) {
+      applyTransform(NT->Trans, L);
+    }
+
+    void applyOne(NodeTy *L, const TransformExecutableDirective *D) {
+      Transform *Trans = D->getTransform();
+      assert(Trans);
+      applyTransform(Trans, L);
+    }
+
+    void traverseSubloops(NodeTy *L) {
+      // Transform subloops first.
+      for (NodeTy *SubL : L->getSubLoops()) {
+        SubL = SubL->getLatestSuccessor();
+        if (!SubL)
+          continue;
+        traverse(SubL);
+      }
+    }
+
+    bool applyTransform(NodeTy *L) {
+      if (L->isRoot())
+        return false;
+      assert(L == L->getLatestSuccessor() &&
+             "Loop must not have been consumed by another transformation");
+
+      Stmt *OrigStmt = L->getInheritedOriginal();
+      auto TransformsOnStmt = TransByStmt.find(OrigStmt);
+      if (TransformsOnStmt != TransByStmt.end()) {
+        auto &List = TransformsOnStmt->second;
+        if (!List.empty()) {
+          NodeTransform *Trans = List.front();
+          applyOne(L, Trans);
+          List.erase(List.begin());
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+    void traverse(NodeTy *L) {
+      do {
+        L = L->getLatestSuccessor();
+        if (!L)
+          break;
+        traverseSubloops(L);
+      } while (applyTransform(L));
+    }
+  };
+
+protected:
+  TransformedTreeBuilder(ASTContext &ASTCtx,
+                         llvm::SmallVectorImpl<NodeTy *> &AllNodes)
+      : ASTCtx(ASTCtx), AllNodes(AllNodes) {}
+
+  NodeTy *createRoot(llvm::ArrayRef<NodeTy *> SubLoops) {
+    auto *Result = new NodeTy(SubLoops, nullptr, nullptr, -1, -1);
+    AllNodes.push_back(Result);
+    Result->IsRoot = true;
+    return Result;
+  }
+
+  NodeTy *createPhysical(llvm::ArrayRef<NodeTy *> SubLoops,
+                         clang::Stmt *Original) {
+    assert(Original);
+    auto *Result = new NodeTy(SubLoops, nullptr, Original, -1, 0);
+    AllNodes.push_back(Result);
+    return Result;
+  }
+
+  NodeTy *createFollowup(llvm::ArrayRef<NodeTy *> SubLoops, NodeTy *BasedOn,
+                         int FollowupRole, int Stage) {
+    assert(BasedOn);
+    auto *Result = new NodeTy(SubLoops, BasedOn, nullptr, FollowupRole, Stage);
+    AllNodes.push_back(Result);
+    return Result;
+  }
+
+public:
+  void markParallel(NodeTy *L) { L->markParallel(); }
+
+  NodeTy *
+  computeTransformedStructure(Stmt *Body,
+                              llvm::DenseMap<Stmt *, NodeTy *> &StmtToTree) {
+    if (!Body)
+      return nullptr;
+
+    // Create original tree.
+    SmallVector<NodeTy *, 8> TopLevelLoops;
+    buildPhysicalLoopTree(Body, TopLevelLoops, StmtToTree);
+    NodeTy *Root = getDerived().createRoot(TopLevelLoops);
+
+    // Collect all loop transformations.
+    CollectTransformationsVisitor Collector(getDerived(), StmtToTree);
+    Collector.TraverseStmt(Body);
+    auto &TransformList = Collector.Transforms;
+
+    // Local function to apply every transformation that the predicate returns
+    // true to. This is to emulate LLVM's pass pipeline that would apply
+    // transformation in this order.
+    auto SelectiveApplicator = [this, &TransformList, Root](auto Pred) {
+      TransformApplicator OMPApplicator(getDerived());
+      bool AnyActive = false;
+      for (NodeTransform &NT : TransformList) {
+        if (Pred(NT)) {
+          OMPApplicator.addNodeTransform(&NT);
+          AnyActive = true;
+        }
+      }
+
+      // No traversal needed if no transformations to apply.
+      if (!AnyActive)
+        return;
+
+      OMPApplicator.traverse(Root);
+
+      // Report leftover transformations.
+      for (auto &P : OMPApplicator.TransByStmt) {
+        for (NodeTransform *NT : P.second) {
+          if (!NT->Trans->isLegacy())
+            getDerived().Diag(NT->Trans->getBeginLoc(),
+                              diag::err_sema_transform_missing_loop);
+        }
+      }
+
+      // Remove applied transformations from list.
+      auto NewEnd =
+          std::remove_if(TransformList.begin(), TransformList.end(), Pred);
+      TransformList.erase(NewEnd, TransformList.end());
+    };
+
+    // Apply full unrolling, loop distribution, vectorization/interleaving.
+    SelectiveApplicator([](NodeTransform &NT) -> bool {
+      if (auto Unroll = dyn_cast<LoopUnrollingTransform>(NT.Trans))
+        return Unroll->isLegacy() && Unroll->isFull();
+      if (auto Dist = dyn_cast<LoopDistributionTransform>(NT.Trans))
+        return Dist->isLegacy();
+      if (auto Vec = dyn_cast<LoopVectorizationInterleavingTransform>(NT.Trans))
+        return Vec->isLegacy();
+      return false;
+    });
+
+    // Apply unrollandjam.
+    // While all transformations in TransformList have already been added in the
+    // order in the pass pipeline (relative to transformations on the same
+    // loop), transformations on unrollandjam's inner loop are not ordered
+    // relative to the outer loop.
+    SelectiveApplicator([](NodeTransform &NT) -> bool {
+      if (auto Unroll = dyn_cast<LoopUnrollAndJamTransform>(NT.Trans))
+        return Unroll->isLegacy();
+      return false;
+    });
+
+    // Apply partial unrolling and software pipelining.
+    SelectiveApplicator([](NodeTransform &NT) -> bool {
+      if (auto Unroll = dyn_cast<LoopUnrollingTransform>(NT.Trans))
+        return Unroll->isLegacy();
+      if (isa<LoopPipeliningTransform>(NT.Trans))
+        return true;
+      return false;
+    });
+
+    // Apply all others.
+    SelectiveApplicator([](NodeTransform &NT) -> bool { return true; });
+    assert(TransformList.size() == 0 && "Must apply all transformations");
+
+    return Root;
+  }
+};
+
+} // namespace clang
+#endif /* LLVM_CLANG_ANALYSIS_ANALYSISTRANSFORM_H */

include/clang/Basic/DiagnosticSemaKinds.td

def err_preserve_field_info_not_field : Error<
   "__builtin_preserve_field_info argument %0 not a field access">;
 def err_preserve_field_info_not_const: Error<
   "__builtin_preserve_field_info argument %0 not a constant">;
 
 def err_bit_cast_non_trivially_copyable : Error<
   "__builtin_bit_cast %select{source|destination}0 type must be trivially copyable">;
 def err_bit_cast_type_size_mismatch : Error<
   "__builtin_bit_cast source size does not equal destination size (%0 vs %1)">;
+
+// Pragma transform support.
+def err_sema_transform_unrollandjam_expect_nested_loop : Error<
+  "unroll-and-jam requires exactly one nested loop">;
+def err_sema_transform_unrollandjam_not_innermost : Error<
+  "inner loop of unroll-and-jam is not the innermost">;
+def err_sema_transform_missing_loop : Error<
+  "transformation did not find its loop to transform; it might have been consumed by another transformations">;
+def err_sema_transform_unroll_full_or_partial : Error<
+  "unroll full/partial clauses specified multiple times">;
+def err_sema_transform_unroll_factor_expect_int : Error<
+  "unroll partial clause expects an int">;
+def err_sema_transform_unroll_partial_once : Error<
+  "unroll-and-jam partial clause can only be used once">;
+def err_sema_transform_vectorize_width_once : Error<
+  "vectorize width clause can only be used once">;
+def err_sema_transform_interleave_factor_once : Error<
+  "interleave factor clause can only be used once">;
+def err_sema_transform_expected_loop : Error<
+  "cannot find loop to transform">;
+def err_sema_transform_unroll_partial_ge_two : Error<
+  "unroll factor must be at least two">;
+  def err_sema_transform_interleave_factor_ge_two : Error<
+  "interleave factor must be at least two">;
+def warn_sema_transform_pass_order : Warning<
+  "the LLVM pass structure currently is not able to apply the transformations in this order">, InGroup<ClangTransform>;
+
 } // end of sema component.

include/clang/Basic/StmtNodes.td

 def SEHExceptStmt : Stmt;
 def SEHFinallyStmt : Stmt;
 def SEHLeaveStmt : Stmt;
 def MSDependentExistsStmt : Stmt;
 
 // OpenCL Extensions.
 def AsTypeExpr : DStmt<Expr>;
 
+// Transform Directives.
+def TransformExecutableDirective : Stmt;
+
 // OpenMP Directives.
 def OMPExecutableDirective : Stmt<1>;
 def OMPLoopDirective : DStmt<OMPExecutableDirective, 1>;
 def OMPParallelDirective : DStmt<OMPExecutableDirective>;
 def OMPSimdDirective : DStmt<OMPLoopDirective>;
 def OMPForDirective : DStmt<OMPLoopDirective>;
 def OMPForSimdDirective : DStmt<OMPLoopDirective>;
 def OMPSectionsDirective : DStmt<OMPExecutableDirective>;

include/clang/Sema/Sema.h

public:
   ActOnLoopTransformDirective(Transform::Kind Kind, Transform *Trans,
                               llvm::ArrayRef<TransformClause *> Clauses,
                               Stmt *AStmt, SourceRange Loc);
 
   TransformClause *ActOnFullClause(SourceRange Loc);
   TransformClause *ActOnPartialClause(SourceRange Loc, Expr *Factor);
   TransformClause *ActOnWidthClause(SourceRange Loc, Expr *Width);
   TransformClause *ActOnFactorClause(SourceRange Loc, Expr *Factor);
+
+  void HandleLoopTransformations(FunctionDecl *FD);
 };
 
 /// RAII object that enters a new expression evaluation context.
 class EnterExpressionEvaluationContext {
   Sema &Actions;
   bool Entered = true;
 
 public:

include/clang/Sema/SemaTransform.h

+//===---- SemaTransform.h ------------------------------------- -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Semantic analysis for code transformations.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_SEMA_SEMATRANSFORM_H
+#define LLVM_CLANG_SEMA_SEMATRANSFORM_H
+
+#include "clang/Analysis/AnalysisTransform.h"
+#include "clang/Sema/Sema.h"
+
+namespace clang {
+class Sema;
+
+class SemaTransformedTree : public TransformedTree<SemaTransformedTree> {
+  friend class TransformedTree<SemaTransformedTree>;
+  using BaseTy = TransformedTree<SemaTransformedTree>;
+  using NodeTy = SemaTransformedTree;
+
+  BaseTy &getBase() { return *this; }
+  const BaseTy &getBase() const { return *this; }
+
+public:
+  SemaTransformedTree(llvm::ArrayRef<NodeTy *> SubLoops, NodeTy *BasedOn,
+                      clang::Stmt *Original, int FollowupRole, int Stage)
+      : TransformedTree(SubLoops, BasedOn, Original, FollowupRole, Stage) {}
+};
+
+class SemaTransformedTreeBuilder
+    : public TransformedTreeBuilder<SemaTransformedTreeBuilder,
+                                    SemaTransformedTree> {
+  using NodeTy = SemaTransformedTree;
+
+  Sema &Sem;
+
+public:
+  SemaTransformedTreeBuilder(ASTContext &ASTCtx,
+                             llvm::SmallVectorImpl<NodeTy *> &AllNodes,
+                             Sema &Sem)
+      : TransformedTreeBuilder(ASTCtx, AllNodes), Sem(Sem) {}
+
+  auto Diag(SourceLocation Loc, unsigned DiagID) {
+    return Sem.Diag(Loc, DiagID);
+  }
+
+  void applyOriginal(SemaTransformedTree *L) {}
+
+  void disableDistribution(SemaTransformedTree *L) {}
+  void disableVectorizeInterleave(SemaTransformedTree *L) {}
+  void disableUnrollAndJam(SemaTransformedTree *L) {}
+  void disableUnroll(SemaTransformedTree *L) {}
+  void disablePipelining(SemaTransformedTree *L) {}
+
+  void applyDistribution(LoopDistributionTransform *Trans,
+                         SemaTransformedTree *InputLoop) {}
+  void applyVectorizeInterleave(LoopVectorizationInterleavingTransform *Trans,
+                                SemaTransformedTree *MainLoop) {}
+  void applyUnrollAndJam(LoopUnrollAndJamTransform *Trans,
+                         SemaTransformedTree *OuterLoop,
+                         SemaTransformedTree *InnerLoop) {}
+  void applyUnroll(LoopUnrollingTransform *Trans,
+                   SemaTransformedTree *OriginalLoop) {}
+  void applyPipelining(LoopPipeliningTransform *Trans,
+                       SemaTransformedTree *MainLoop) {}
+
+  void inheritLoopAttributes(SemaTransformedTree *Dst, SemaTransformedTree *Src,
+                             bool IsAll, bool IsSuccessor) {}
+};
+
+} // namespace clang
+#endif /* LLVM_CLANG_SEMA_SEMATRANSFORM_H */

lib/AST/ASTTypeTraits.cpp

 #define STMT(DERIVED, BASE) { NKI_##BASE, #DERIVED },
 #include "clang/AST/StmtNodes.inc"
     {NKI_None, "Type"},
 #define TYPE(DERIVED, BASE) { NKI_##BASE, #DERIVED "Type" },
 #include "clang/AST/TypeNodes.inc"
     {NKI_None, "OMPClause"},
 #define OPENMP_CLAUSE(TextualSpelling, Class) {NKI_OMPClause, #Class},
 #include "clang/Basic/OpenMPKinds.def"
+    {NKI_TransformClause, "TransformClause"},
+#define TRANSFORM_CLAUSE(Keyword, Name) {NKI_##Name##Clause, #Name "Clause"},
+#include "clang/AST/TransformKinds.def"
+    {NKI_Transform, "Transform"},
+#define TRANSFORM_DIRECTIVE(Keyworld, Name)                                    \
+  {NKI_##Name##Transform, #Name "Transform"},
+#include "clang/AST/TransformKinds.def"
 };
 
 bool ASTNodeKind::isBaseOf(ASTNodeKind Other, unsigned *Distance) const {
   return isBaseOf(KindId, Other.KindId, Distance);
 }
 
 bool ASTNodeKind::isBaseOf(NodeKindId Base, NodeKindId Derived,
                            unsigned *Distance) {
#include "clang/Basic/OpenMPKinds.def"
   case OMPC_device_type:
   case OMPC_match:
   case OMPC_unknown:
     llvm_unreachable("unexpected OpenMP clause kind");
   }
   llvm_unreachable("invalid stmt kind");
 }
 
+ASTNodeKind ASTNodeKind::getFromNode(const Transform &T) {
+  switch (T.getKind()) {
+#define TRANSFORM_DIRECTIVE(Keyword, Name)                                     \
+  case Transform::Kind::Name##Kind:                                            \
+    return ASTNodeKind(NKI_##Transform);
+#include "clang/AST/TransformKinds.def"
+  case Transform::Kind::UnknownKind:
+    llvm_unreachable("unexpected transform kind");
+  }
+  llvm_unreachable("invalid transform kind");
+}
+
+ASTNodeKind ASTNodeKind::getFromNode(const TransformClause &C) {
+  switch (C.getKind()) {
+#define TRANSFORM_CLAUSE(Keyword, Name)                                        \
+  case TransformClause::Kind ::Name##Kind:                                     \
+    return ASTNodeKind(NKI_##Name##Clause);
+#include "clang/AST/TransformKinds.def"
+  case TransformClause::Kind::UnknownKind:
+    llvm_unreachable("unexpected transform kind");
+  }
+  llvm_unreachable("invalid transform kind");
+}
+
 void DynTypedNode::print(llvm::raw_ostream &OS,
                          const PrintingPolicy &PP) const {
   if (const TemplateArgument *TA = get<TemplateArgument>())
     TA->print(PP, OS);
   else if (const TemplateName *TN = get<TemplateName>())
     TN->print(OS, PP);
   else if (const NestedNameSpecifier *NNS = get<NestedNameSpecifier>())
     NNS->print(OS, PP);

lib/AST/JSONNodeDumper.cpp

else if (Init->isDelegatingInitializer())
     JOS.attribute("delegatingInit",
                   createQualType(Init->getTypeSourceInfo()->getType()));
   else
     llvm_unreachable("Unknown initializer type");
 }
 
 void JSONNodeDumper::Visit(const OMPClause *C) {}
 
+void JSONNodeDumper::Visit(const TransformClause *C) {}
+
+void JSONNodeDumper::Visit(const Transform *T) {}
+
 void JSONNodeDumper::Visit(const BlockDecl::Capture &C) {
   JOS.attribute("kind", "Capture");
   attributeOnlyIfTrue("byref", C.isByRef());
   attributeOnlyIfTrue("nested", C.isNested());
   if (C.getVariable())
     JOS.attribute("var", createBareDeclRef(C.getVariable()));
 }
 

lib/AST/StmtPrinter.cpp

 #include "clang/AST/ExprOpenMP.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/OpenMPClause.h"
 #include "clang/AST/PrettyPrinter.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/AST/StmtObjC.h"
 #include "clang/AST/StmtOpenMP.h"
+#include "clang/AST/StmtTransform.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/ExpressionTraits.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/JsonSupport.h"
 #include "clang/Basic/LLVM.h"
void StmtPrinter::VisitSEHFinallyStmt(SEHFinallyStmt *Node) {
   OS << NL;
 }
 
 void StmtPrinter::VisitSEHLeaveStmt(SEHLeaveStmt *Node) {
   Indent() << "__leave;";
   if (Policy.IncludeNewlines) OS << NL;
 }
 
+void StmtPrinter::VisitTransformExecutableDirective(
+    TransformExecutableDirective *Node) {
+  Indent() << "#pragma clang transform "
+           << Transform ::getTransformDirectiveKeyword(
+                  Node->getTransformKind());
+  for (TransformClause *Clause : Node->clauses()) {
+    OS << ' ';
+    Clause->print(OS, Policy);
+  }
+  OS << NL;
+  PrintStmt(Node->getAssociated());
+}
+
 //===----------------------------------------------------------------------===//
 //  OpenMP directives printing methods
 //===----------------------------------------------------------------------===//
 
 void StmtPrinter::PrintOMPExecutableDirective(OMPExecutableDirective *S,
                                               bool ForceNoStmt) {
   OMPClausePrinter Printer(OS, Policy);
   ArrayRef<OMPClause *> Clauses = S->clauses();

lib/AST/StmtProfile.cpp

void OMPClauseProfiler::VisitOMPUseDevicePtrClause(
   VisitOMPClauseList(C);
 }
 void OMPClauseProfiler::VisitOMPIsDevicePtrClause(
     const OMPIsDevicePtrClause *C) {
   VisitOMPClauseList(C);
 }
 }
 
+void StmtProfiler::VisitTransformExecutableDirective(
+    const TransformExecutableDirective *S) {
+  VisitStmt(S);
+}
+
 void
 StmtProfiler::VisitOMPExecutableDirective(const OMPExecutableDirective *S) {
   VisitStmt(S);
   OMPClauseProfiler P(this);
   ArrayRef<OMPClause *> Clauses = S->clauses();
   for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
        I != E; ++I)
     if (*I)

lib/AST/StmtTransform.cpp

 
 #include "clang/AST/StmtTransform.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/StmtOpenMP.h"
 
 using namespace clang;
 
+TransformExecutableDirective *TransformExecutableDirective::create(
+    ASTContext &Ctx, SourceRange Range, Stmt *Associated, Transform *Trans,
+    ArrayRef<TransformClause *> Clauses, Transform::Kind TransKind) {
+  void *Mem = Ctx.Allocate(totalSizeToAlloc<TransformClause *>(Clauses.size()));
+  return new (Mem) TransformExecutableDirective(Range, Associated, Trans,
+                                                Clauses, TransKind);
+}
+
+TransformExecutableDirective *
+TransformExecutableDirective::createEmpty(ASTContext &Ctx,
+                                          unsigned NumClauses) {
+  void *Mem = Ctx.Allocate(totalSizeToAlloc<TransformClause *>(NumClauses));
+  return new (Mem) TransformExecutableDirective(NumClauses);
+}
+
+llvm::StringRef TransformClause::getClauseName(Kind K) {
+  assert(K >= UnknownKind);
+  assert(K <= LastKind);
+  const char *Names[LastKind + 1] = {
+      "Unknown",
+#define TRANSFORM_CLAUSE(Keyword, Name) #Name,
+#include "clang/AST/TransformKinds.def"
+  };
+  return Names[K];
+}
+
 bool TransformClause::isValidForTransform(Transform::Kind TransformKind,
                                           TransformClause::Kind ClauseKind) {
   switch (TransformKind) {
   case clang::Transform::LoopUnrollingKind:
     return ClauseKind == PartialKind || ClauseKind == FullKind;
   case clang::Transform::LoopUnrollAndJamKind:
     return ClauseKind == PartialKind;
   case clang::Transform::LoopVectorizationKind:

 #define TRANSFORM_CLAUSE(Keyword, Name)                                        \
   if (isValidForTransform(TransformKind, TransformClause::Kind::Name##Kind) && \
       Str == #Keyword)                                                         \
     return TransformClause::Kind::Name##Kind;
 #include "clang/AST/TransformKinds.def"
   return TransformClause::UnknownKind;
 }
 
+TransformClause ::child_range TransformClause ::children() {
+  switch (getKind()) {
+  case UnknownKind:
+    llvm_unreachable("Unknown child");
+#define TRANSFORM_CLAUSE(Keyword, Name)                                        \
+  case TransformClause::Kind::Name##Kind:                                      \
+    return static_cast<Name##Clause *>(this)->children();
+#include "clang/AST/TransformKinds.def"
+  }
+  llvm_unreachable("Unhandled clause kind");
+}
+
+void TransformClause ::print(llvm::raw_ostream &OS,
+                             const PrintingPolicy &Policy) const {
+  assert(getKind() > UnknownKind);
+  assert(getKind() <= LastKind);
+  static decltype(&TransformClause::print) PrintFuncs[LastKind] = {
+#define TRANSFORM_CLAUSE(Keyword, Name)                                        \
+  static_cast<decltype(&TransformClause::print)>(&Name##Clause ::print),
+#include "clang/AST/TransformKinds.def"
+  };
+  (this->*PrintFuncs[getKind() - 1])(OS, Policy);
+}
+
+void FullClause::print(llvm::raw_ostream &OS,
+                       const PrintingPolicy &Policy) const {
+  OS << "full";
+}
+
+void PartialClause::print(llvm::raw_ostream &OS,
+                          const PrintingPolicy &Policy) const {
+  OS << "partial(";
+  Factor->printPretty(OS, nullptr, Policy, 0);
+  OS << ')';
+}
+
+void WidthClause::print(llvm::raw_ostream &OS,
+                        const PrintingPolicy &Policy) const {
+  OS << "width(";
+  Width->printPretty(OS, nullptr, Policy, 0);
+  OS << ')';
+}
+
+void FactorClause::print(llvm::raw_ostream &OS,
+                         const PrintingPolicy &Policy) const {
+  OS << "factor(";
+  Factor->printPretty(OS, nullptr, Policy, 0);
+  OS << ')';
+}
+
 const Stmt *clang::getAssociatedLoop(const Stmt *S) {
   switch (S->getStmtClass()) {
   case Stmt::ForStmtClass:
   case Stmt::WhileStmtClass:
   case Stmt::DoStmtClass:
   case Stmt::CXXForRangeStmtClass:
     return S;
   case Stmt::CapturedStmtClass:
     return getAssociatedLoop(cast<CapturedStmt>(S)->getCapturedStmt());
   case Stmt::AttributedStmtClass:
     return getAssociatedLoop(cast<AttributedStmt>(S)->getSubStmt());
+  case Stmt::TransformExecutableDirectiveClass:
+    return getAssociatedLoop(
+        cast<TransformExecutableDirective>(S)->getAssociated());
   default:
     if (auto LD = dyn_cast<OMPLoopDirective>(S))
       return getAssociatedLoop(LD->getAssociatedStmt());
   }
 
   return nullptr;
 }

lib/AST/TextNodeDumper.cpp

OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
        << ClauseName.drop_front() << "Clause";
   }
   dumpPointer(C);
   dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
   if (C->isImplicit())
     OS << " <implicit>";
 }
 
+void TextNodeDumper::VisitTransformExecutableDirective(
+    const TransformExecutableDirective *S) {
+  if (S)
+    AddChild([=] { Visit(S->getTransform()); });
+}
+
+void TextNodeDumper::Visit(const TransformClause *C) {
+  if (!C) {
+    ColorScope Color(OS, ShowColors, NullColor);
+    OS << "<<<NULL>>> TransformClause";
+    return;
+  }
+  {
+    ColorScope Color(OS, ShowColors, AttrColor);
+    StringRef ClauseName = TransformClause::getClauseName(C->getKind());
+    OS << ClauseName << "Clause";
+  }
+  dumpPointer(C);
+  dumpSourceRange(C->getLoc());
+}
+
+void TextNodeDumper::Visit(const Transform *T) {
+  if (!T) {
+    ColorScope Color(OS, ShowColors, NullColor);
+    OS << "<<<NULL>>> Transform";
+    return;
+  }
+  {
+    ColorScope Color(OS, ShowColors, AttrColor);
+    StringRef TransformName =
+        Transform::getTransformDirectiveName(T->getKind());
+    OS << TransformName << "Transform";
+  }
+  dumpPointer(T);
+  dumpSourceRange(T->getLoc());
+}
+
 void TextNodeDumper::Visit(const GenericSelectionExpr::ConstAssociation &A) {
   const TypeSourceInfo *TSI = A.getTypeSourceInfo();
   if (TSI) {
     OS << "case ";
     dumpType(TSI->getType());
   } else {
     OS << "default";
   }

lib/AST/Transform.cpp

llvm::StringRef Transform ::getTransformDirectiveName(Kind K) {
   assert(K <= LastKind);
   const char *Keywords[LastKind + 1] = {
       "<<Unknown>>",
 #define TRANSFORM_DIRECTIVE(Keyword, Name) #Name,
 #include "clang/AST/TransformKinds.def"
   };
   return Keywords[K];
 }
+
+int Transform::getLoopPipelineStage() const {
+  switch (getKind()) {
+  case Transform::Kind::LoopDistributionKind:
+    return 1;
+  case Transform::Kind::LoopUnrollingKind:
+    return cast<LoopUnrollingTransform>(this)->isFull() ? 0 : 4;
+  case Transform::Kind::LoopInterleavingKind:
+  case Transform::Kind::LoopVectorizationKind:
+  case Transform::Kind::LoopVectorizationInterleavingKind:
+    return 2;
+  case Transform::Kind::LoopUnrollAndJamKind:
+    return 3;
+  default:
+    return -1;
+  }
+}
+
+int Transform::getNumInputs() const {
+  assert(getKind() > UnknownKind);
+  assert(getKind() <= LastKind);
+  static const decltype(
+      &Transform::getNumInputs) GetNumInputFuncs[Transform::Kind::LastKind] = {
+#define TRANSFORM_DIRECTIVE(Keyword, Name)                                     \
+  static_cast<decltype(&Transform::getNumInputs)>(                             \
+      &Name##Transform ::getNumInputs),
+#include "clang/AST/TransformKinds.def"
+  };
+  return (this->*GetNumInputFuncs[getKind() - 1])();
+}
+
+int Transform::getNumFollowups() const {
+  assert(getKind() > UnknownKind);
+  assert(getKind() <= LastKind);
+  static const decltype(&Transform::getNumInputs)
+      GetNumFollowupFuncs[Transform::Kind::LastKind] = {
+#define TRANSFORM_DIRECTIVE(Keyword, Name)                                     \
+  static_cast<decltype(&Transform::getNumFollowups)>(                          \
+      &Name##Transform ::getNumFollowups),
+#include "clang/AST/TransformKinds.def"
+      };
+  return (this->*GetNumFollowupFuncs[getKind() - 1])();
+}

lib/CodeGen/CGStmt.cpp

#include "clang/AST/StmtNodes.inc"
   case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
     EmitOMPTargetTeamsDistributeParallelForSimdDirective(
         cast<OMPTargetTeamsDistributeParallelForSimdDirective>(*S));
     break;
   case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
     EmitOMPTargetTeamsDistributeSimdDirective(
         cast<OMPTargetTeamsDistributeSimdDirective>(*S));
     break;
+  case Stmt::TransformExecutableDirectiveClass:
+    llvm_unreachable("not implemented");
+    break;
   }
 }
 
 bool CodeGenFunction::EmitSimpleStmt(const Stmt *S) {
   switch (S->getStmtClass()) {
   default: return false;
   case Stmt::NullStmtClass: break;
   case Stmt::CompoundStmtClass: EmitCompoundStmt(cast<CompoundStmt>(*S)); break;

lib/Sema/SemaDecl.cpp

if (Body && (!FD || !FD->isDefaulted())) {
     assert(ExprCleanupObjects.size() ==
                ExprEvalContexts.back().NumCleanupObjects &&
            "Leftover temporaries in function");
     assert(!Cleanup.exprNeedsCleanups() && "Unaccounted cleanups in function");
     assert(MaybeODRUseExprs.empty() &&
            "Leftover expressions for odr-use checking");
   }
 
+  HandleLoopTransformations(FD);
+
   if (!IsInstantiation)
     PopDeclContext();
 
   PopFunctionScopeInfo(ActivePolicy, dcl);
   // If any errors have occurred, clear out any temporaries that may have
   // been leftover. This ensures that these temporaries won't be picked up for
   // deletion in some later function.
   if (getDiagnostics().hasErrorOccurred()) {

lib/Sema/SemaTransform.cpp

 //===---- SemaTransform.h ------------------------------------- -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Semantic analysis for code transformations.
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/Sema/SemaTransform.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/StmtTransform.h"
 #include "clang/AST/Transform.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaDiagnostic.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
 
 using namespace clang;
 
 static bool isTemplateDependent(Expr *E) {
   return E->isValueDependent() || E->isTypeDependent() ||
          E->isInstantiationDependent() || E->containsUnexpandedParameterPack();
 }
 
 Sema::TransformResult
 Sema::ActOnTransform(Transform::Kind Kind,
                      llvm::ArrayRef<TransformClause *> Clauses,
                      SourceRange Loc) {
-  // TOOD: implement
-  return TransformError();
+  SmallVector<TransformClause *, 2> ClauseByKind[TransformClause::LastKind + 1];
+  for (TransformClause *Clause : Clauses) {
+    ClauseByKind[Clause->getKind()].push_back(Clause);
+  }
+
+  switch (Kind) {
+  case Transform::LoopUnrollingKind: {
+    FullClause *Full = nullptr;
+    PartialClause *Partial = nullptr;
+    for (TransformClause *Clause : Clauses) {
+      switch (Clause->getKind()) {
+      case TransformClause::FullKind:
+        if (Full || Partial) {
+          Diag(Clause->getBeginLoc(),
+               diag::err_sema_transform_unroll_full_or_partial);
+          continue;
+        }
+        Full = cast<FullClause>(Clause);
+        break;
+      case TransformClause::PartialKind:
+        if (Full || Partial) {
+          Diag(Clause->getBeginLoc(),
+               diag::err_sema_transform_unroll_full_or_partial);
+          continue;
+        }
+        Partial = cast<PartialClause>(Clause);
+        break;
+      default:
+        llvm_unreachable("Clause not supported by unroll");
+      }
+    }
+
+    assert(!Full || !Partial);
+
+    if (Full)
+      return LoopUnrollingTransform::createFull(Loc, false, true, true);
+    else if (Partial) {
+      Expr *FactorExpr = Partial->getFactor();
+      if (isTemplateDependent(FactorExpr))
+        return {};
+      Expr::EvalResult FactorRes;
+      FactorExpr->EvaluateAsInt(FactorRes, Context);
+      if (!FactorRes.Val.isInt())
+        return TransformError(
+            Diag(FactorExpr->getExprLoc(),
+                 diag::err_sema_transform_unroll_factor_expect_int));
+      llvm::APSInt FactorVal = FactorRes.Val.getInt();
+      int64_t FactorInt = FactorVal.getSExtValue();
+      return LoopUnrollingTransform::createPartial(Loc, false, true, true,
+                                                   FactorInt);
+    }
+
+    return LoopUnrollingTransform::create(Loc, false, true, true);
+  }
+
+  case Transform::LoopUnrollAndJamKind: {
+    PartialClause *Partial = nullptr;
+    for (TransformClause *Clause : Clauses) {
+      switch (Clause->getKind()) {
+      case TransformClause::PartialKind:
+        if (Partial) {
+          Diag(Clause->getBeginLoc(),
+               diag::err_sema_transform_unroll_partial_once);
+          continue;
+        }
+        Partial = cast<PartialClause>(Clause);
+        break;
+      default:
+        llvm_unreachable("Clause not supported by unroll-and-jam");
+      }
+    }
+
+    if (Partial) {
+      Expr *FactorExpr = Partial->getFactor();
+      if (isTemplateDependent(FactorExpr))
+        return {};
+      Expr::EvalResult FactorRes;
+      FactorExpr->EvaluateAsInt(FactorRes, Context);
+      llvm::APSInt FactorVal = FactorRes.Val.getInt();
+      int64_t FactorInt = FactorVal.getSExtValue();
+      return LoopUnrollAndJamTransform::createPartial(Loc, false, true,
+                                                      FactorInt);
+    }
+
+    return LoopUnrollAndJamTransform::create(Loc, false, true);
+  }
+
+  case clang::Transform::LoopDistributionKind:
+    assert(Clauses.size() == 0 && "distribute has no clauses");
+    return LoopDistributionTransform::create(Loc, false);
+
+  case clang::Transform::LoopVectorizationKind: {
+    WidthClause *Width = nullptr;
+    for (TransformClause *Clause : Clauses) {
+      switch (Clause->getKind()) {
+      case TransformClause::WidthKind:
+        if (Width) {
+          Diag(Clause->getBeginLoc(),
+               diag::err_sema_transform_vectorize_width_once);
+          continue;
+        }
+        Width = cast<WidthClause>(Clause);
+        break;
+
+      default:
+        llvm_unreachable("Clause not supported by distribute");
+      }
+    }
+
+    int64_t WidthInt = 0;
+    if (Width) {
+      if (isTemplateDependent(Width->getWidth()))
+        return {};
+
+      Expr::EvalResult WidthRes;
+      Width->getWidth()->EvaluateAsInt(WidthRes, Context);
+      llvm::APSInt WidthVal = WidthRes.Val.getInt();
+      WidthInt = WidthVal.getSExtValue();
+    }
+
+    return LoopVectorizationTransform::Create(Loc, true, WidthInt, None);
+  }
+
+  case clang::Transform::LoopInterleavingKind: {
+    FactorClause *Factor = nullptr;
+
+    for (TransformClause *Clause : Clauses) {
+      switch (Clause->getKind()) {
+      case TransformClause::FactorKind:
+        if (Factor) {
+          Diag(Clause->getBeginLoc(),
+               diag::err_sema_transform_interleave_factor_once);
+          continue;
+        }
+        Factor = cast<FactorClause>(Clause);
+        break;
+      default:
+        llvm_unreachable("Clause not supported by distribute");
+      }
+    }
+
+    int64_t FactorInt = 0;
+    if (Factor) {
+      if (isTemplateDependent(Factor->getFactor()))
+        return {};
+
+      Expr::EvalResult FactorRes;
+      Factor->getFactor()->EvaluateAsInt(FactorRes, Context);
+      llvm::APSInt FactorVal = FactorRes.Val.getInt();
+      FactorInt = FactorVal.getSExtValue();
+    }
+
+    return LoopInterleavingTransform::Create(Loc, true, FactorInt);
+  }
+  default:
+    llvm_unreachable("unimplemented");
+  }
 }
 
 StmtResult
 Sema::ActOnLoopTransformDirective(Transform::Kind Kind, Transform *Trans,
                                   llvm::ArrayRef<TransformClause *> Clauses,
                                   Stmt *AStmt, SourceRange Loc) {
-  // TOOD: implement
-  return StmtError();
+  const Stmt *Loop = getAssociatedLoop(AStmt);
+  if (!Loop)
+    return StmtError(
+        Diag(Loc.getBegin(), diag::err_sema_transform_expected_loop));
+
+  if (!Trans) {
+    TransformResult Transform = ActOnTransform(Kind, Clauses, Loc);
+    Trans = Transform.isUsable() ? Transform.get() : nullptr;
+  }
+
+  return TransformExecutableDirective::create(Context, Loc, AStmt, Trans,
+                                              Clauses, Kind);
 }
 
 TransformClause *Sema::ActOnFullClause(SourceRange Loc) {
-  // TOOD: implement
-  return nullptr;
+  return FullClause::create(Context, Loc);
 }
 
 TransformClause *Sema::ActOnPartialClause(SourceRange Loc, Expr *Factor) {
-  // TOOD: implement
+  if (!Factor->isValueDependent() && Factor->isEvaluatable(getASTContext())) {
+    llvm::APSInt ValueAPS = Factor->EvaluateKnownConstInt(getASTContext());
+    if (!ValueAPS.sge(2)) {
+      Diag(Loc.getBegin(), diag::err_sema_transform_unroll_partial_ge_two);
       return nullptr;
     }
+  }
+  return PartialClause::create(Context, Loc, Factor);
+}
 
 TransformClause *Sema::ActOnWidthClause(SourceRange Loc, Expr *Width) {
-  // TOOD: implement
-  return nullptr;
+  return WidthClause::create(Context, Loc, Width);
 }
 
 TransformClause *Sema::ActOnFactorClause(SourceRange Loc, Expr *Factor) {
-  // TOOD: implement
+  if (!Factor->isValueDependent() && Factor->isEvaluatable(getASTContext())) {
+    llvm::APSInt ValueAPS = Factor->EvaluateKnownConstInt(getASTContext());
+    if (!ValueAPS.sge(2)) {
+      Diag(Loc.getBegin(), diag::err_sema_transform_interleave_factor_ge_two);
       return nullptr;
     }
+  }
+  return FactorClause::create(Context, Loc, Factor);
+}
+
+void Sema::HandleLoopTransformations(FunctionDecl *FD) {
+  if (!FD || FD->isInvalidDecl())
+    return;
+
+  // Note: this is called on a template-code and the instantiated code.
+  llvm::DenseMap<Stmt *, SemaTransformedTree *> StmtToTree;
+  llvm::SmallVector<SemaTransformedTree *, 64> AllNodes;
+  SemaTransformedTreeBuilder Builder(getASTContext(), AllNodes, *this);
+  Builder.computeTransformedStructure(FD->getBody(), StmtToTree);
+
+  for (auto N : AllNodes)
+    delete N;
+}

lib/Sema/TreeTransform.h

 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ExprOpenMP.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/AST/StmtObjC.h"
 #include "clang/AST/StmtOpenMP.h"
+#include "clang/AST/StmtTransform.h"
 #include "clang/Sema/Designator.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Ownership.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaDiagnostic.h"
 #include "clang/Sema/SemaInternal.h"
 #include "llvm/ADT/ArrayRef.h"
public:
   /// appropriate TransformXXXStmt function to transform a specific kind of
   /// statement or the TransformExpr() function to transform an expression.
   /// Subclasses may override this function to transform statements using some
   /// other mechanism.
   ///
   /// \returns the transformed statement.
   StmtResult TransformStmt(Stmt *S, StmtDiscardKind SDK = SDK_Discarded);
 
+  Transform *TransformTransform(Transform *T) { return T; }
+
+  TransformClause *TransformTransformClause(TransformClause *S);
+
+  TransformClause *TransformFullClause(FullClause *C) {
+    return RebuildFullClause(C->getLoc());
+  }
+
+  TransformClause *RebuildFullClause(SourceRange Loc) {
+    return getSema().ActOnFullClause(Loc);
+  }
+
+  TransformClause *TransformPartialClause(PartialClause *C) {
+    ExprResult E = getDerived().TransformExpr(C->getFactor());
+    if (E.isInvalid())
+      return nullptr;
+    return getDerived().RebuildPartialClause(C->getLoc(), E.get());
+  }
+
+  TransformClause *RebuildPartialClause(SourceRange Loc, Expr *Factor) {
+    return getSema().ActOnPartialClause(Loc, Factor);
+  }
+
+  TransformClause *TransformWidthClause(WidthClause *C) {
+    ExprResult E = getDerived().TransformExpr(C->getWidth());
+    if (E.isInvalid())
+      return nullptr;
+    return getDerived().RebuildWidthClause(C->getLoc(), E.get());
+  }
+
+  TransformClause *RebuildWidthClause(SourceRange Loc, Expr *Width) {
+    return getSema().ActOnWidthClause(Loc, Width);
+  }
+
+  TransformClause *TransformFactorClause(FactorClause *C) {
+    ExprResult E = getDerived().TransformExpr(C->getFactor());
+    if (E.isInvalid())
+      return nullptr;
+    return getDerived().RebuildFactorClause(C->getLoc(), E.get());
+  }
+
+  TransformClause *RebuildFactorClause(SourceRange Loc, Expr *Factor) {
+    return getSema().ActOnFactorClause(Loc, Factor);
+  }
+
   /// Transform the given statement.
   ///
   /// By default, this routine transforms a statement by delegating to the
   /// appropriate TransformOMPXXXClause function to transform a specific kind
   /// of clause. Subclasses may override this function to transform statements
   /// using some other mechanism.
   ///
   /// \returns the transformed OpenMP clause.
#include "clang/Basic/OpenMPKinds.def"
   ///
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
   StmtResult RebuildObjCAtThrowStmt(SourceLocation AtLoc,
                                           Expr *Operand) {
     return getSema().BuildObjCAtThrowStmt(AtLoc, Operand);
   }
 
+  StmtResult
+  RebuildTransformExecutableDirective(Transform::Kind Kind, Transform *Trans,
+                                      llvm::ArrayRef<TransformClause *> Clauses,
+                                      Stmt *AStmt, SourceRange Loc) {
+    StmtResult Result =
+        getSema().ActOnLoopTransformDirective(Kind, Trans, Clauses, AStmt, Loc);
+    assert(!Result.isUsable() ||
+           isa<TransformExecutableDirective>(Result.get()));
+    return Result;
+  }
+
   /// Build a new OpenMP executable directive.
   ///
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
   StmtResult RebuildOMPExecutableDirective(OpenMPDirectiveKind Kind,
                                            DeclarationNameInfo DirName,
                                            OpenMPDirectiveKind CancelRegion,
                                            ArrayRef<OMPClause *> Clauses,

 }
 
 template<typename Derived>
 StmtResult
 TreeTransform<Derived>::TransformSEHLeaveStmt(SEHLeaveStmt *S) {
   return S;
 }
 
+template <typename Derived>
+TransformClause *
+TreeTransform<Derived>::TransformTransformClause(TransformClause *S) {
+  if (!S)
+    return S;
+
+  switch (S->getKind()) {
+#define TRANSFORM_CLAUSE(Keyword, Name)                                        \
+  case TransformClause::Kind::Name##Kind:                                      \
+    return getDerived().Transform##Name##Clause(cast<Name##Clause>(S));
+#include "clang/AST/TransformKinds.def"
+  case TransformClause::Kind::UnknownKind:
+    llvm_unreachable("Should not be unknown");
+  }
+
+  return S;
+}
+
+template <typename Derived>
+StmtResult TreeTransform<Derived>::TransformTransformExecutableDirective(
+    TransformExecutableDirective *D) {
+  llvm::SmallVector<TransformClause *, 16> TClauses;
+  for (TransformClause *C : D->clauses()) {
+    TransformClause *TClause = getDerived().TransformTransformClause(C);
+    TClauses.push_back(TClause);
+  }
+
+  Stmt *AStmt = D->getAssociated();
+  StmtResult TBody = getDerived().TransformStmt(AStmt);
+  assert(TBody.isUsable());
+
+  Transform *Trans = getDerived().TransformTransform(D->getTransform());
+  StmtResult TDirective = getDerived().RebuildTransformExecutableDirective(
+      D->getTransformKind(), Trans, TClauses, TBody.get(), D->getLoc());
+  return TDirective;
+}
+
 //===----------------------------------------------------------------------===//
 // OpenMP directive transformation
 //===----------------------------------------------------------------------===//
 template <typename Derived>
 StmtResult TreeTransform<Derived>::TransformOMPExecutableDirective(
     OMPExecutableDirective *D) {
 
   // Transform the clauses

lib/Serialization/ASTReaderStmt.cpp

 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
   VisitExpr(E);
   E->BuiltinLoc = ReadSourceLocation();
   E->RParenLoc = ReadSourceLocation();
   E->SrcExpr = Record.readSubExpr();
 }
 
 //===----------------------------------------------------------------------===//
+// Transformation Directives.
+//===----------------------------------------------------------------------===//
+
+void ASTStmtReader::VisitTransformExecutableDirective(
+    TransformExecutableDirective *D) {
+  llvm_unreachable("not implemented");
+}
+
+//===----------------------------------------------------------------------===//
 // OpenMP Directives.
 //===----------------------------------------------------------------------===//
 
 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
   E->setLocStart(ReadSourceLocation());
   E->setLocEnd(ReadSourceLocation());
   OMPClauseReader ClauseReader(Record);
   SmallVector<OMPClause *, 5> Clauses;

lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) {
   Code = serialization::STMT_SEH_TRY;
 }
 
 void ASTStmtWriter::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
   VisitStmt(S);
   Record.AddSourceLocation(S->getLeaveLoc());
   Code = serialization::STMT_SEH_LEAVE;
 }
+//===----------------------------------------------------------------------===//
+// Transformation Directives.
+//===----------------------------------------------------------------------===//
+
+void ASTStmtWriter::VisitTransformExecutableDirective(
+    TransformExecutableDirective *D) {
+  llvm_unreachable("not implemented");
+}
 
 //===----------------------------------------------------------------------===//
 // OpenMP Directives.
 //===----------------------------------------------------------------------===//
 void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
   Record.AddSourceLocation(E->getBeginLoc());
   Record.AddSourceLocation(E->getEndLoc());
   OMPClauseWriter ClauseWriter(Record);

test/AST/ast-dump-transform-unroll.c

+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck %s
+
+void unroll_full(int n) {
+#pragma clang transform unroll full
+  for (int i = 0; i < 4; i+=1)
+    ;
+}
+
+// CHECK: FunctionDecl {{.*}} unroll_full
+// CHECK: TransformExecutableDirective
+// CHECK-NEXT: LoopUnrollingTransform
+// CHECK-NEXT: FullClause
+// CHECK-NEXT: ForStmt
+
+
+void unroll_partial(int n) {
+#pragma clang transform unroll partial(4)
+  for (int i = 0; i < n; i+=1)
+    ;
+}
+
+// CHECK-LABEL: FunctionDecl {{.*}} unroll_partial
+// CHECK: TransformExecutableDirective
+// CHECK-NEXT: LoopUnrollingTransform
+// CHECK-NEXT: PartialClause
+// CHECK-NEXT:   IntegerLiteral
+// CHECK-NEXT: ForStmt

test/AST/ast-print-pragma-transform-distribute.cpp

+// RUN: %clang_cc1 -ast-print %s -o - | FileCheck %s
+
+void distribute(int *List, int Length) {
+// CHECK: #pragma clang transform distribute
+#pragma clang transform distribute
+// CHECK-NEXT: for (int i = 0; i < Length; i += 1)
+  for (int i = 0; i < Length; i += 1) 
+    List[i] = i; 
+}

test/AST/ast-print-pragma-transform-interleave.cpp

+// RUN: %clang_cc1 -ast-print %s -o - | FileCheck %s
+
+void unroll(int *List, int Length) {
+// CHECK: #pragma clang transform interleave factor(4)
+#pragma clang transform interleave factor(4)
+// CHECK-NEXT: for (int i = 0; i < Length; i += 1)
+  for (int i = 0; i < Length; i += 1) 
+    List[i] = i; 
+}

test/AST/ast-print-pragma-transform-unroll.cpp

+// RUN: %clang_cc1 -ast-print %s -o - | FileCheck %s
+
+void unroll(int *List, int Length) {
+// CHECK: #pragma clang transform unroll partial(4)
+#pragma clang transform unroll partial(4)
+// CHECK-NEXT: for (int i = 0; i < Length; i += 1)
+  for (int i = 0; i < Length; i += 1)
+    List[i] = i;
+
+// CHECK: #pragma clang transform unroll full
+#pragma clang transform unroll full
+// CHECK-NEXT: for (int i = 0; i < Length; i += 1)
+  for (int i = 0; i < Length; i += 1)
+    List[i] = i;
+}

test/AST/ast-print-pragma-transform-unrollandjam.cpp

+// RUN: %clang_cc1 -ast-print %s -o - | FileCheck %s
+
+void unroll(int *List, int Length) {
+// CHECK: #pragma clang transform unrollandjam partial(4)
+#pragma clang transform unrollandjam partial(4)
+// CHECK-NEXT: for (int i = 0; i < Length; i += 1)
+  for (int i = 0; i < Length; i += 1)
+    for (int j = 0; j < Length; j += 1)
+      List[i] += j;
+}

test/AST/ast-print-pragma-transform-vectorize.cpp

+// RUN: %clang_cc1 -ast-print %s -o - | FileCheck %s
+
+void unroll(int *List, int Length) {
+// CHECK: #pragma clang transform vectorize width(4)
+#pragma clang transform vectorize width(4)
+// CHECK-NEXT: for (int i = 0; i < Length; i += 1)
+  for (int i = 0; i < Length; i += 1) 
+    List[i] = i; 
+}

test/SemaCXX/pragma-transform-interleave.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+
+void interleave(int *List, int Length, int Value) {
+/* expected-error@+1 {{interleave factor clause can only be used once}} */
+#pragma clang transform interleave factor(4) factor(4)
+  for (int i = 0; i < Length; i++)
+      List[i] = Value;
+}

test/SemaCXX/pragma-transform-unroll.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+
+void unroll(int *List, int Length, int Value) {
+/* expected-error@+1 {{unroll factor must be at least two}} */
+#pragma clang transform unroll partial(0)
+  for (int i = 0; i < 8; i++)
+      List[i] = Value;
+
+/* expected-error@+1 {{unroll full/partial clauses specified multiple times}} */
+#pragma clang transform unroll full full
+  for (int i = 0; i < 8; i++)
+      List[i] = Value;
+
+/* expected-error@+1 {{unroll full/partial clauses specified multiple times}} */
+#pragma clang transform unroll partial(4) partial(4)
+  for (int i = 0; i < 8; i++)
+      List[i] = Value;
+
+/* expected-error@+1 {{unroll full/partial clauses specified multiple times}} */
+#pragma clang transform unroll full partial(4)
+  for (int i = 0; i < 8; i++)
+      List[i] = Value;
+
+/* expected-error@+1 {{transformation did not find its loop to transform}} */
+#pragma clang transform unroll
+#pragma clang transform unroll full
+  for (int i = 0; i < 8; i++)
+      List[i] = Value;
+
+int f = 4;
+  /* expected-error@+1 {{unroll partial clause expects an int}} */
+#pragma clang transform unroll partial(f)
+  for (int i = 0; i < Length; i+=1)
+    List[i] = i;
+
+}

test/SemaCXX/pragma-transform-unrollandjam.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+
+void unrollandjam(int *List, int Length, int Value) {
+/* expected-error@+1 {{unroll-and-jam partial clause can only be used once}} */
+#pragma clang transform unrollandjam partial(4) partial(4)
+  for (int i = 0; i < Length; i++)
+    for (int j = 0; j < Length; j++)
+      List[i] += j*Value;
+
+/* expected-error@+1 {{unroll-and-jam requires exactly one nested loop}} */
+#pragma clang transform unrollandjam
+  for (int i = 0; i < Length; i++)
+      List[i] = Value;
+
+/* expected-error@+1 {{unroll-and-jam requires exactly one nested loop}} */
+#pragma clang transform unrollandjam
+  for (int i = 0; i < Length; i++) {
+    for (int j = 0; j < Length; j++)
+      List[i] += j*Value;
+    for (int j = 0; j < Length; j++)
+      List[i] += j*Value;
+  }
+
+/* expected-error@+1 {{inner loop of unroll-and-jam is not the innermost}} */
+#pragma clang transform unrollandjam
+  for (int i = 0; i < Length; i++)
+    for (int j = 0; j < Length; j++)
+      for (int k = 0; k < Length; k++)
+        List[i] += k + j*Value;
+}

test/SemaCXX/pragma-transform-vectorize.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+
+void vectorize(int *List, int Length, int Value) {
+/* expected-error@+1 {{vectorize width clause can only be used once}} */
+#pragma clang transform vectorize width(4) width(4)
+  for (int i = 0; i < Length; i++)
+      List[i] = Value;
+}

test/SemaCXX/pragma-transform-wrongorder.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+
+void wrongorder(int *List, int Length, int Value) {
+
+/* expected-warning@+1 {{the LLVM pass structure currently is not able to apply the transformations in this order}} */
+#pragma clang transform distribute
+#pragma clang transform vectorize
+  for (int i = 0; i < 8; i++)
+    List[i] = Value;
+
+/* expected-warning@+1 {{the LLVM pass structure currently is not able to apply the transformations in this order}} */
+#pragma clang transform vectorize
+#pragma clang transform unrollandjam
+  for (int i = 0; i < 8; i++)
+    for (int j = 0; j < 8; j++)
+      List[i] += j;
+
+}

tools/libclang/CXCursor.cpp

CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent,
   case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
     K = CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective;
     break;
   case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
     K = CXCursor_OMPTargetTeamsDistributeSimdDirective;
     break;
   case Stmt::BuiltinBitCastExprClass:
     K = CXCursor_BuiltinBitCastExpr;
+    break;
+  case Stmt::TransformExecutableDirectiveClass:
+    llvm_unreachable("not implemented");
   }
 
   CXCursor C = { K, 0, { Parent, S, TU } };
   return C;
 }
 
 CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super,
                                                SourceLocation Loc,