EIC code displayed by LXR master/​include/​polly/​CodeGen/​IslAst.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-10 08:48:11

 //===- IslAst.h - Interface to the isl code generator -----------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // The isl code generator interface takes a Scop and generates a isl_ast. This
 // ist_ast can either be returned directly or it can be pretty printed to
 // stdout.
 //
 // A typical isl_ast output looks like this:
 //
 // for (c2 = max(0, ceild(n + m, 2); c2 <= min(511, floord(5 * n, 3)); c2++) {
 //   bb2(c2);
 // }
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef POLLY_ISLAST_H
 #define POLLY_ISLAST_H
 
 #include "polly/ScopPass.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/IR/PassManager.h"
 #include "isl/ctx.h"
 
 namespace polly {
 using llvm::SmallPtrSet;
 
 class Dependences;
 
 class IslAst final {
 public:
   IslAst(const IslAst &) = delete;
   IslAst &operator=(const IslAst &) = delete;
   IslAst(IslAst &&);
   IslAst &operator=(IslAst &&) = delete;
 
   static IslAst create(Scop &Scop, const Dependences &D);
 
   isl::ast_node getAst();
 
   const std::shared_ptr<isl_ctx> getSharedIslCtx() const { return Ctx; }
 
   /// Get the run-time conditions for the Scop.
   isl::ast_expr getRunCondition();
 
   /// Build run-time condition for scop.
   ///
   /// @param S     The scop to build the condition for.
   /// @param Build The isl_build object to use to build the condition.
   ///
   /// @returns An ast expression that describes the necessary run-time check.
   static isl::ast_expr buildRunCondition(Scop &S, const isl::ast_build &Build);
 
 private:
   Scop &S;
   std::shared_ptr<isl_ctx> Ctx;
   isl::ast_expr RunCondition;
   isl::ast_node Root;
 
   IslAst(Scop &Scop);
 
   void init(const Dependences &D);
 };
 
 class IslAstInfo {
 public:
   using MemoryAccessSet = SmallPtrSet<MemoryAccess *, 4>;
 
   /// Payload information used to annotate an AST node.
   struct IslAstUserPayload {
     /// Construct and initialize the payload.
     IslAstUserPayload() = default;
 
     /// Does the dependence analysis determine that there are no loop-carried
     /// dependencies?
     bool IsParallel = false;
 
     /// Flag to mark innermost loops.
     bool IsInnermost = false;
 
     /// Flag to mark innermost parallel loops.
     bool IsInnermostParallel = false;
 
     /// Flag to mark outermost parallel loops.
     bool IsOutermostParallel = false;
 
     /// Flag to mark parallel loops which break reductions.
     bool IsReductionParallel = false;
 
     /// The minimal dependence distance for non parallel loops.
     isl::pw_aff MinimalDependenceDistance;
 
     /// The build environment at the time this node was constructed.
     isl::ast_build Build;
 
     /// Set of accesses which break reduction dependences.
     MemoryAccessSet BrokenReductions;
   };
 
 private:
   Scop &S;
   IslAst Ast;
 
 public:
   IslAstInfo(Scop &S, const Dependences &D) : S(S), Ast(IslAst::create(S, D)) {}
 
   /// Return the isl AST computed by this IslAstInfo.
   IslAst &getIslAst() { return Ast; }
 
   /// Return a copy of the AST root node.
   isl::ast_node getAst();
 
   /// Get the run condition.
   ///
   /// Only if the run condition evaluates at run-time to a non-zero value, the
   /// assumptions that have been taken hold. If the run condition evaluates to
   /// zero/false some assumptions do not hold and the original code needs to
   /// be executed.
   isl::ast_expr getRunCondition();
 
   void print(raw_ostream &O);
 
   /// @name Extract information attached to an isl ast (for) node.
   ///
   ///{
   /// Get the complete payload attached to @p Node.
   static IslAstUserPayload *getNodePayload(const isl::ast_node &Node);
 
   /// Is this loop an innermost loop?
   static bool isInnermost(const isl::ast_node &Node);
 
   /// Is this loop a parallel loop?
   static bool isParallel(const isl::ast_node &Node);
 
   /// Is this loop an outermost parallel loop?
   static bool isOutermostParallel(const isl::ast_node &Node);
 
   /// Is this loop an innermost parallel loop?
   static bool isInnermostParallel(const isl::ast_node &Node);
 
   /// Is this loop a reduction parallel loop?
   static bool isReductionParallel(const isl::ast_node &Node);
 
   /// Will the loop be run as thread parallel?
   static bool isExecutedInParallel(const isl::ast_node &Node);
 
   /// Get the nodes schedule or a nullptr if not available.
   static isl::union_map getSchedule(const isl::ast_node &Node);
 
   /// Get minimal dependence distance or nullptr if not available.
   static isl::pw_aff getMinimalDependenceDistance(const isl::ast_node &Node);
 
   /// Get the nodes broken reductions or a nullptr if not available.
   static MemoryAccessSet *getBrokenReductions(const isl::ast_node &Node);
 
   /// Get the nodes build context or a nullptr if not available.
   static isl::ast_build getBuild(const isl::ast_node &Node);
 
   ///}
 };
 
 struct IslAstAnalysis : AnalysisInfoMixin<IslAstAnalysis> {
   static AnalysisKey Key;
 
   using Result = IslAstInfo;
 
   IslAstInfo run(Scop &S, ScopAnalysisManager &SAM,
                  ScopStandardAnalysisResults &SAR);
 };
 
 class IslAstInfoWrapperPass final : public ScopPass {
   std::unique_ptr<IslAstInfo> Ast;
 
 public:
   static char ID;
 
   IslAstInfoWrapperPass() : ScopPass(ID) {}
 
   IslAstInfo &getAI() { return *Ast; }
   const IslAstInfo &getAI() const { return *Ast; }
 
   /// Build the AST for the given SCoP @p S.
   bool runOnScop(Scop &S) override;
 
   /// Register all analyses and transformation required.
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 
   /// Release the internal memory.
   void releaseMemory() override;
 
   /// Print a source code representation of the program.
   void printScop(raw_ostream &OS, Scop &S) const override;
 };
 
 llvm::Pass *createIslAstInfoWrapperPassPass();
 llvm::Pass *createIslAstInfoPrinterLegacyPass(llvm::raw_ostream &OS);
 
 struct IslAstPrinterPass final : PassInfoMixin<IslAstPrinterPass> {
   IslAstPrinterPass(raw_ostream &OS) : OS(OS) {}
 
   PreservedAnalyses run(Scop &S, ScopAnalysisManager &SAM,
                         ScopStandardAnalysisResults &, SPMUpdater &U);
 
   raw_ostream &OS;
 };
 } // namespace polly
 
 namespace llvm {
 void initializeIslAstInfoWrapperPassPass(llvm::PassRegistry &);
 void initializeIslAstInfoPrinterLegacyPassPass(llvm::PassRegistry &);
 } // namespace llvm
 
 #endif // POLLY_ISLAST_H

This page was automatically generated by the 2.3.7 LXR engine. The LXR team