blob: 059205c629ee02532e071cbe0e2cb523fcce2309 [file] [log] [blame]
//===- IslAst.h - Interface to the isl code generator -----------*- C++ -*-===//
// The LLVM Compiler Infrastructure
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
// 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);
// }
#include "polly/Config/config.h"
#include "polly/ScopPass.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/IR/PassManager.h"
#include "isl/ast.h"
#include "isl/ctx.h"
#include <memory>
namespace llvm {
class PassRegistry;
class raw_ostream;
void initializeIslAstInfoWrapperPassPass(PassRegistry &);
} // namespace llvm
struct isl_ast_build;
struct isl_ast_expr;
struct isl_ast_node;
struct isl_pw_aff;
struct isl_pw_multi_aff;
struct isl_union_map;
namespace polly {
struct Dependences;
class MemoryAccess;
class Scop;
class IslAst {
IslAst(const IslAst &) = delete;
IslAst &operator=(const IslAst &) = delete;
IslAst(IslAst &&);
IslAst &operator=(IslAst &&) = delete;
static IslAst create(Scop &Scop, const Dependences &D);
/// Print a source code representation of the program.
void pprint(raw_ostream &OS);
__isl_give isl_ast_node *getAst();
const std::shared_ptr<isl_ctx> getSharedIslCtx() const { return Ctx; }
/// Get the run-time conditions for the Scop.
__isl_give 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,
__isl_keep isl_ast_build *Build);
Scop &S;
isl_ast_node *Root = nullptr;
isl_ast_expr *RunCondition = nullptr;
std::shared_ptr<isl_ctx> Ctx;
IslAst(Scop &Scop);
void init(const Dependences &D);
class IslAstInfo {
using MemoryAccessSet = SmallPtrSet<MemoryAccess *, 4>;
/// Payload information used to annotate an AST node.
struct IslAstUserPayload {
/// Construct and initialize the payload.
IslAstUserPayload() = default;
/// Cleanup all isl structs on destruction.
/// 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 = nullptr;
/// Set of accesses which break reduction dependences.
MemoryAccessSet BrokenReductions;
Scop &S;
IslAst Ast;
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_give 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_give 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(__isl_keep isl_ast_node *Node);
/// Is this loop an innermost loop?
static bool isInnermost(__isl_keep isl_ast_node *Node);
/// Is this loop a parallel loop?
static bool isParallel(__isl_keep isl_ast_node *Node);
/// Is this loop an outermost parallel loop?
static bool isOutermostParallel(__isl_keep isl_ast_node *Node);
/// Is this loop an innermost parallel loop?
static bool isInnermostParallel(__isl_keep isl_ast_node *Node);
/// Is this loop a reduction parallel loop?
static bool isReductionParallel(__isl_keep isl_ast_node *Node);
/// Will the loop be run as thread parallel?
static bool isExecutedInParallel(__isl_keep isl_ast_node *Node);
/// Get the nodes schedule or a nullptr if not available.
static __isl_give isl_union_map *getSchedule(__isl_keep isl_ast_node *Node);
/// Get minimal dependence distance or nullptr if not available.
static __isl_give isl_pw_aff *
getMinimalDependenceDistance(__isl_keep isl_ast_node *Node);
/// Get the nodes broken reductions or a nullptr if not available.
static MemoryAccessSet *getBrokenReductions(__isl_keep isl_ast_node *Node);
/// Get the nodes build context or a nullptr if not available.
static __isl_give isl_ast_build *getBuild(__isl_keep isl_ast_node *Node);
struct IslAstAnalysis : public AnalysisInfoMixin<IslAstAnalysis> {
static AnalysisKey Key;
using Result = IslAstInfo;
IslAstInfo run(Scop &S, ScopAnalysisManager &SAM,
ScopStandardAnalysisResults &SAR);
class IslAstInfoWrapperPass : public ScopPass {
std::unique_ptr<IslAstInfo> Ast;
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;
struct IslAstPrinterPass : public PassInfoMixin<IslAstPrinterPass> {
IslAstPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Scop &S, ScopAnalysisManager &SAM,
ScopStandardAnalysisResults &, SPMUpdater &U);
raw_ostream &OS;
} // namespace polly
#endif // POLLY_ISLAST_H