scan.h

   1 #include <map>
   2
   3 #include <clang/Basic/SourceManager.h>
   4 #include <clang/AST/Decl.h>
   5 #include <clang/AST/Stmt.h>
   6 #include <clang/Lex/Preprocessor.h>
   7
   8 #include <isl/ctx.h>
   9 #include <isl/map.h>
  10
  11 #include "scop.h"
  12
  13 /* The location of the scop, as delimited by scop and endscop
  14  * pragmas by the user.
  15  */
  16 struct ScopLoc {
  17         ScopLoc() : end(0) {}
  18
  19         unsigned start;
  20         unsigned end;
  21 };
  22
  23 struct PetScan {
  24         clang::Preprocessor &PP;
  25         clang::ASTContext &ast_context;
  26         /* If autodetect is false, then loc contains the location
  27          * of the scop to be extracted.
  28          */
  29         ScopLoc &loc;
  30         isl_ctx *ctx;
  31         pet_options *options;
  32         /* The sequence number of the next statement. */
  33         int n_stmt;
  34         /* The sequence number of the next virtual scalar. */
  35         int n_test;
  36         /* Set if the pet_scop returned by an extract method only
  37          * represents part of the input tree.
  38          */
  39         bool partial;
  40         /* Set is nested accesses are allowed in general.
  41          * This currently defaults to true.
  42          */
  43         bool allow_nested;
  44         /* Set if nested accesses are allowed in that part of the tree
  45          * that is currently under investigation.
  46          */
  47         bool nesting_enabled;
  48         /* Maps identifiers to the last value that was assigned to them.
  49          * If an identifier is mapped to NULL, then something may have
  50          * been assigned, but we don't know what.
  51          * assigned_value does not take a reference to the isl_pw_aff
  52          * object, so each such isl_pw_aff needs to be stored in
  53          * the set of "expressions".
  54          */
  55         std::map<clang::ValueDecl *, isl_pw_aff *> assigned_value;
  56         /* A collection of isl_pw_affs used in assigned_value or other
  57          * temporary maps.  expressions holds a reference for each
  58          * isl_pw_aff, which is freed in the destructor of PetScan.
  59          */
  60         std::set<isl_pw_aff *> expressions;
  61
  62         /* A union of mappings of the form
  63          *      { identifier[] -> [i] : lower_bound <= i <= upper_bound }
  64          */
  65         isl_union_map *value_bounds;
  66
  67         PetScan(clang::Preprocessor &PP,
  68                 clang::ASTContext &ast_context, ScopLoc &loc,
  69                 pet_options *options, __isl_take isl_union_map *value_bounds) :
  70                 ctx(isl_union_map_get_ctx(value_bounds)), PP(PP),
  71                 ast_context(ast_context), loc(loc),
  72                 options(options), value_bounds(value_bounds),
  73                 n_stmt(0), n_test(0), partial(0), allow_nested(true),
  74                 nesting_enabled(false) { }
  75
  76         ~PetScan();
  77
  78         struct pet_scop *scan(clang::FunctionDecl *fd);
  79
  80         static int extract_int(clang::IntegerLiteral *expr, isl_int *v);
  81 private:
  82         void assign(struct pet_expr *lhs, clang::Expr *rhs);
  83
  84         __isl_give isl_pw_aff *signed_overflow(__isl_take isl_pw_aff *pa,
  85                 unsigned width);
  86         void insert_expression(__isl_take isl_pw_aff *expr);
  87         struct pet_scop *scan(clang::Stmt *stmt);
  88
  89         struct pet_scop *scan_arrays(struct pet_scop *scop);
  90         struct pet_array *extract_array(isl_ctx *ctx, clang::ValueDecl *decl);
  91         struct pet_array *set_upper_bounds(struct pet_array *array,
  92                 const clang::Type *type, int pos);
  93
  94         struct pet_scop *extract_non_affine_condition(clang::Expr *cond,
  95                 __isl_take isl_map *access);
  96
  97         struct pet_scop *extract_conditional_assignment(clang::IfStmt *stmt);
  98         struct pet_scop *extract_non_affine_if(clang::Expr *cond,
  99                 struct pet_scop *scop_then, struct pet_scop *scop_else,
 100                 bool have_else, int stmt_id);
 101
 102         struct pet_scop *kill(clang::Stmt *stmt, struct pet_array *array);
 103
 104         struct pet_scop *extract(clang::Stmt *stmt,
 105                 bool skip_declarations = false);
 106         struct pet_scop *extract(clang::StmtRange stmt_range, bool block,
 107                 bool skip_declarations);
 108         struct pet_scop *extract(clang::IfStmt *stmt);
 109         struct pet_scop *extract(clang::WhileStmt *stmt);
 110         struct pet_scop *extract(clang::CompoundStmt *stmt,
 111                 bool skip_declarations = false);
 112         struct pet_scop *extract(clang::LabelStmt *stmt);
 113         struct pet_scop *extract(clang::ContinueStmt *stmt);
 114         struct pet_scop *extract(clang::BreakStmt *stmt);
 115         struct pet_scop *extract(clang::DeclStmt *expr);
 116
 117         struct pet_scop *extract(clang::Stmt *stmt, struct pet_expr *expr,
 118                                 __isl_take isl_id *label = NULL);
 119         struct pet_stmt *extract_kill(struct pet_scop *scop);
 120
 121         clang::BinaryOperator *initialization_assignment(clang::Stmt *init);
 122         clang::Decl *initialization_declaration(clang::Stmt *init);
 123         clang::ValueDecl *extract_induction_variable(clang::BinaryOperator *stmt);
 124         clang::VarDecl *extract_induction_variable(clang::Stmt *init,
 125                                 clang::Decl *stmt);
 126         __isl_give isl_pw_aff *extract_unary_increment(clang::UnaryOperator *op,
 127                                 clang::ValueDecl *iv);
 128         __isl_give isl_pw_aff *extract_binary_increment(
 129                                 clang::BinaryOperator *op,
 130                                 clang::ValueDecl *iv);
 131         __isl_give isl_pw_aff *extract_compound_increment(
 132                                 clang::CompoundAssignOperator *op,
 133                                 clang::ValueDecl *iv);
 134         __isl_give isl_pw_aff *extract_increment(clang::ForStmt *stmt,
 135                                 clang::ValueDecl *iv);
 136         struct pet_scop *extract_for(clang::ForStmt *stmt);
 137         struct pet_scop *extract_infinite_loop(clang::Stmt *body);
 138         struct pet_scop *extract_infinite_for(clang::ForStmt *stmt);
 139         struct pet_scop *extract_affine_while(__isl_take isl_pw_aff *pa,
 140                                 clang::Stmt *body);
 141
 142         void mark_write(struct pet_expr *access);
 143         struct pet_expr *extract_expr(clang::Expr *expr);
 144         struct pet_expr *extract_expr(clang::UnaryOperator *expr);
 145         struct pet_expr *extract_expr(clang::BinaryOperator *expr);
 146         struct pet_expr *extract_expr(clang::ImplicitCastExpr *expr);
 147         struct pet_expr *extract_expr(clang::FloatingLiteral *expr);
 148         struct pet_expr *extract_expr(clang::ParenExpr *expr);
 149         struct pet_expr *extract_expr(clang::ConditionalOperator *expr);
 150         struct pet_expr *extract_expr(clang::CallExpr *expr);
 151
 152         int extract_nested(__isl_keep isl_space *space,
 153                 int n_arg, struct pet_expr **args,
 154                 std::map<int,int> &param2pos);
 155         struct pet_expr *extract_nested(struct pet_expr *expr, int n,
 156                 std::map<int,int> &param2pos);
 157         struct pet_stmt *extract_nested(struct pet_stmt *stmt, int n,
 158                 std::map<int,int> &param2pos);
 159         struct pet_expr *resolve_nested(struct pet_expr *expr);
 160         struct pet_scop *resolve_nested(struct pet_scop *scop);
 161         struct pet_stmt *resolve_nested(struct pet_stmt *stmt);
 162         struct pet_expr *extract_access_expr(clang::Expr *expr);
 163
 164         __isl_give isl_map *extract_access(clang::ArraySubscriptExpr *expr);
 165         __isl_give isl_map *extract_access(clang::Expr *expr);
 166         __isl_give isl_map *extract_access(clang::ImplicitCastExpr *expr);
 167         __isl_give isl_map *extract_access(clang::DeclRefExpr *expr);
 168         __isl_give isl_map *extract_access(clang::ValueDecl *decl);
 169         __isl_give isl_map *extract_access(clang::IntegerLiteral *expr);
 170
 171         int extract_int(clang::Expr *expr, isl_int *v);
 172         int extract_int(clang::ParenExpr *expr, isl_int *v);
 173
 174         __isl_give isl_pw_aff *extract_affine_add(clang::BinaryOperator *expr);
 175         __isl_give isl_pw_aff *extract_affine_div(clang::BinaryOperator *expr);
 176         __isl_give isl_pw_aff *extract_affine_mod(clang::BinaryOperator *expr);
 177         __isl_give isl_pw_aff *extract_affine_mul(clang::BinaryOperator *expr);
 178
 179         isl_pw_aff *nested_access(clang::Expr *expr);
 180
 181         __isl_give isl_pw_aff *try_extract_affine(clang::Expr *expr);
 182         bool is_affine(clang::Expr *expr);
 183         __isl_give isl_pw_aff *try_extract_affine_condition(clang::Expr *expr);
 184         bool is_affine_condition(clang::Expr *expr);
 185         __isl_give isl_pw_aff *try_extract_nested_condition(clang::Expr *expr);
 186         bool is_nested_allowed(__isl_keep isl_pw_aff *pa, pet_scop *scop);
 187
 188         __isl_give isl_pw_aff *extract_affine(const llvm::APInt &val);
 189         __isl_give isl_pw_aff *extract_affine(clang::Expr *expr);
 190         __isl_give isl_pw_aff *extract_affine(clang::IntegerLiteral *expr);
 191         __isl_give isl_pw_aff *extract_affine(clang::ImplicitCastExpr *expr);
 192         __isl_give isl_pw_aff *extract_affine(clang::DeclRefExpr *expr);
 193         __isl_give isl_pw_aff *extract_affine(clang::BinaryOperator *expr);
 194         __isl_give isl_pw_aff *extract_affine(clang::UnaryOperator *expr);
 195         __isl_give isl_pw_aff *extract_affine(clang::ParenExpr *expr);
 196         __isl_give isl_pw_aff *extract_affine(clang::CallExpr *expr);
 197         __isl_give isl_pw_aff *extract_affine(clang::ArraySubscriptExpr *expr);
 198         __isl_give isl_pw_aff *extract_affine(clang::ConditionalOperator *expr);
 199
 200         __isl_give isl_pw_aff *extract_implicit_condition(clang::Expr *expr);
 201
 202         __isl_give isl_pw_aff *extract_condition(clang::UnaryOperator *expr);
 203         __isl_give isl_pw_aff *extract_condition(clang::Expr *expr);
 204         __isl_give isl_pw_aff *extract_comparison(clang::BinaryOperator *expr);
 205         __isl_give isl_pw_aff *extract_comparison(clang::BinaryOperatorKind op,
 206                 clang::Expr *LHS, clang::Expr *RHS, clang::Stmt *comp);
 207         __isl_give isl_pw_aff *extract_boolean(clang::BinaryOperator *expr);
 208         __isl_give isl_pw_aff *extract_boolean(clang::UnaryOperator *expr);
 209
 210         void unsupported(clang::Stmt *stmt, const char *msg = NULL);
 211 };