/usr/lib/llvm-4.0/include/polly/CodeGen/IslAst.h is in libclang-common-4.0-dev 1:4.0.1-10~deb9u2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 | //===- 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);
// }
//
//===----------------------------------------------------------------------===//
#ifndef POLLY_ISL_AST_H
#define POLLY_ISL_AST_H
#include "polly/Config/config.h"
#include "polly/ScopPass.h"
#include "isl/ast.h"
namespace llvm {
class raw_ostream;
} // namespace llvm
struct isl_pw_aff;
struct isl_ast_node;
struct isl_ast_expr;
struct isl_ast_build;
struct isl_union_map;
struct isl_pw_multi_aff;
namespace polly {
class Scop;
class IslAst;
class MemoryAccess;
struct Dependences;
class IslAst {
public:
static IslAst *create(Scop *Scop, const Dependences &D);
~IslAst();
/// Print a source code representation of the program.
void pprint(llvm::raw_ostream &OS);
__isl_give isl_ast_node *getAst();
/// 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);
private:
Scop *S;
isl_ast_node *Root;
isl_ast_expr *RunCondition;
std::shared_ptr<isl_ctx> Ctx;
IslAst(Scop *Scop);
void init(const Dependences &D);
};
class IslAstInfo : public ScopPass {
public:
using MemoryAccessSet = SmallPtrSet<MemoryAccess *, 4>;
/// Payload information used to annotate an AST node.
struct IslAstUserPayload {
/// Construct and initialize the payload.
IslAstUserPayload()
: IsInnermost(false), IsInnermostParallel(false),
IsOutermostParallel(false), IsReductionParallel(false),
MinimalDependenceDistance(nullptr), Build(nullptr) {}
/// Cleanup all isl structs on destruction.
~IslAstUserPayload();
/// Flag to mark innermost loops.
bool IsInnermost;
/// Flag to mark innermost parallel loops.
bool IsInnermostParallel;
/// Flag to mark outermost parallel loops.
bool IsOutermostParallel;
/// Flag to mark parallel loops which break reductions.
bool IsReductionParallel;
/// 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:
static char ID;
IslAstInfo() : ScopPass(ID), S(nullptr), Ast(nullptr) {}
/// 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(llvm::raw_ostream &OS, Scop &S) const override;
/// Return a copy of the AST root node.
__isl_give isl_ast_node *getAst() const;
/// 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() const;
/// @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);
///}
};
} // namespace polly
namespace llvm {
class PassRegistry;
void initializeIslAstInfoPass(llvm::PassRegistry &);
} // namespace llvm
#endif /* POLLY_ISL_AST_H */
|