gcc/graphite-cloog-compat.h

   1 /* Compatibility layer for using upstream CLooG versions with
   2    CLooG legacy code.
   3    Copyright (C) 2010 Free Software Foundation, Inc.
   4    Contributed by Andreas Simbuerger <simbuerg@fim.uni-passau.de>.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #ifndef GRAPHITE_CLOOG_COMPAT_H
  23 #define GRAPHITE_CLOOG_COMPAT_H
  24
  25 /* Restore compatibility to CLooG Legacy.  */
  26 #ifdef CLOOG_ORG
  27 typedef const struct clast_expr *clast_name_p;
  28 typedef unsigned matrix_num_type;
  29 #else
  30 typedef const char *clast_name_p;
  31 typedef int matrix_num_type;
  32 #endif
  33
  34 #ifdef CLOOG_ORG
  35 #define cloog_initialize()
  36 #define cloog_finalize()
  37 #endif
  38
  39 #ifndef CLOOG_ORG
  40
  41 /* CloogOptions compatibility.  */
  42 #define build_cloog_prog(SCOP, PROG, OPT, STATE)\
  43   build_cloog_prog (SCOP, PROG, STATE)
  44 #define cloog_program_extract_scalars(PROG, SCATT, OPT)\
  45   cloog_program_extract_scalars (PROG, SCATT)
  46 #define cloog_program_scatter(PROG, SCATT, OPT)\
  47   cloog_program_scatter (PROG, SCATT)
  48
  49 /* CLAST compatibility.  */
  50 #define clast_expr_term expr_term
  51 #define clast_expr_red expr_red
  52 #define clast_expr_bin expr_bin
  53 #define clast_pprint pprint
  54
  55 /* CloogState compatibility.  */
  56 #define CloogState void
  57 #define cloog_state_malloc() NULL
  58 #define cloog_state_free(STATE)
  59 #define cloog_loop_malloc(STATE) cloog_loop_malloc ()
  60 #define cloog_options_malloc(STATE) cloog_options_malloc ()
  61 #define cloog_statement_alloc(STATE, INDEX) cloog_statement_alloc (INDEX)
  62 #define new_Cloog_Domain_from_ppl_Pointset_Powerset(PSPS, NB, STATE)\
  63   new_Cloog_Domain_from_ppl_Pointset_Powerset (PSPS)
  64 #define new_Cloog_Domain_from_ppl_Polyhedron(POLY, NB, STATE)\
  65   new_Cloog_Domain_from_ppl_Polyhedron (POLY)
  66 #define cloog_domain_from_cloog_matrix(STATE, MAT, NB)\
  67   cloog_domain_matrix2domain (MAT)
  68
  69 /* CloogScatteringList compatibility.  */
  70 #define CloogScatteringList CloogDomainList
  71 #define CloogScattering CloogDomain
  72 #define cloog_set_next_scattering cloog_set_next_domain
  73 #define cloog_set_scattering cloog_set_domain
  74 #define cloog_scattering cloog_domain
  75 #define cloog_next_scattering cloog_next_domain
  76 #define cloog_scattering_free cloog_domain_free
  77 #define cloog_program_dump_cloog(DUMPFILE, PROGRAM, SCATTERINGLIST)\
  78   cloog_program_dump_cloog (DUMPFILE, PROGRAM)
  79
  80 /* Returns a string of characters for NAME.  */
  81
  82 static inline const char *
  83 clast_name_to_str (clast_name_p name)
  84 {
  85   return (const char *) name;
  86 }
  87
  88 #endif
  89
  90 /* Adapt CLooG accessors from CLooG legacy to
  91    newer CLooG versions.  */
  92
  93 #ifdef CLOOG_ORG
  94
  95 static inline void *
  96 cloog_statement_usr (CloogStatement *cs)
  97 {
  98   return cs->usr;
  99 }
 100
 101 static inline CloogScattering *
 102 cloog_scattering (CloogScatteringList *sl)
 103 {
 104   return sl->scatt;
 105 }
 106
 107 static inline void
 108 cloog_set_scattering (CloogScatteringList *sl, CloogScattering *scatt)
 109 {
 110   sl->scatt = scatt;
 111 }
 112
 113 static inline CloogScatteringList *
 114 cloog_next_scattering (CloogScatteringList *sl)
 115 {
 116   return sl->next;
 117 }
 118
 119 static inline void
 120 cloog_set_next_scattering (CloogScatteringList *sl, CloogScatteringList *next)
 121 {
 122   sl->next = next;
 123 }
 124
 125 static inline int
 126 cloog_program_nb_scattdims (CloogProgram *prog)
 127 {
 128   return prog->nb_scattdims;
 129 }
 130
 131 static inline void
 132 cloog_program_set_nb_scattdims (CloogProgram *prog, int nb_scattdims)
 133 {
 134   prog->nb_scattdims = nb_scattdims;
 135 }
 136
 137 static inline CloogNames *
 138 cloog_program_names (CloogProgram *prog)
 139 {
 140   return prog->names;
 141 }
 142
 143 static inline void
 144 cloog_program_set_names (CloogProgram *prog, CloogNames *names)
 145 {
 146   prog->names = names;
 147 }
 148
 149 static inline void
 150 cloog_program_set_context (CloogProgram *prog, CloogDomain *domain)
 151 {
 152   prog->context = domain;
 153 }
 154
 155 static inline void
 156 cloog_program_set_loop (CloogProgram *prog, CloogLoop *loop)
 157 {
 158   prog->loop = loop;
 159 }
 160
 161 static inline CloogBlockList *
 162 cloog_program_blocklist (CloogProgram *prog)
 163 {
 164   return prog->blocklist;
 165 }
 166
 167 static inline void
 168 cloog_program_set_blocklist (CloogProgram *prog, CloogBlockList *bl)
 169 {
 170   prog->blocklist = bl;
 171 }
 172
 173 static inline int *
 174 cloog_program_scaldims (CloogProgram *prog)
 175 {
 176   return prog->scaldims;
 177 }
 178
 179 static inline void
 180 cloog_program_set_scaldims (CloogProgram *prog, int *s)
 181 {
 182   prog->scaldims = s;
 183 }
 184
 185 static inline int
 186 cloog_names_nb_parameters (CloogNames *names)
 187 {
 188   return names->nb_parameters;
 189 }
 190
 191 static inline void
 192 cloog_names_set_nb_parameters (CloogNames *names, int nb_parameters)
 193 {
 194   names->nb_parameters = nb_parameters;
 195 }
 196
 197 static inline char **
 198 cloog_names_parameters (CloogNames *names)
 199 {
 200   return names->parameters;
 201 }
 202
 203 static inline void
 204 cloog_names_set_parameters (CloogNames *names, char **parameters)
 205 {
 206   names->parameters = parameters;
 207 }
 208
 209 static inline void
 210 cloog_names_set_nb_iterators (CloogNames *names, int nb_iterators)
 211 {
 212   names->nb_iterators = nb_iterators;
 213 }
 214
 215 static inline void
 216 cloog_names_set_iterators (CloogNames *names, char **iterators)
 217 {
 218   names->iterators = iterators;
 219 }
 220
 221 static inline void
 222 cloog_names_set_nb_scattering (CloogNames *names, int nb_scattering)
 223 {
 224   names->nb_scattering = nb_scattering;
 225 }
 226
 227 static inline int
 228 cloog_names_nb_scattering (CloogNames *names)
 229 {
 230   return names->nb_scattering;
 231 }
 232
 233 static inline void
 234 cloog_names_set_scattering (CloogNames *names, char **scattering)
 235 {
 236   names->scattering = scattering;
 237 }
 238
 239 static inline char **
 240 cloog_names_scattering (CloogNames *names)
 241 {
 242   return names->scattering;
 243 }
 244
 245 static inline void
 246 cloog_statement_set_usr (CloogStatement *cs, void *u)
 247 {
 248   cs->usr = u;
 249 }
 250
 251 static inline void
 252 cloog_loop_set_next (CloogLoop *loop, CloogLoop *next)
 253 {
 254   loop->next = next;
 255 }
 256
 257 static inline void
 258 cloog_loop_set_domain (CloogLoop *loop, CloogDomain *domain)
 259 {
 260   loop->domain = domain;
 261 }
 262
 263 static inline void
 264 cloog_loop_set_block (CloogLoop *loop, CloogBlock *block)
 265 {
 266   loop->block = block;
 267 }
 268
 269 static inline CloogBlockList *
 270 cloog_block_list_next (CloogBlockList *bl)
 271 {
 272   return bl->next;
 273 }
 274
 275 static inline void
 276 cloog_block_list_set_next (CloogBlockList *bl, CloogBlockList *next)
 277 {
 278   bl->next = next;
 279 }
 280
 281 static inline void
 282 cloog_block_list_set_block (CloogBlockList *bl, CloogBlock *block)
 283 {
 284   bl->block = block;
 285 }
 286
 287 static inline int cloog_matrix_ncolumns (CloogMatrix * m)
 288 {
 289   return m->NbColumns;
 290 }
 291
 292 static inline int cloog_matrix_nrows (CloogMatrix * m)
 293 {
 294    return m->NbRows;
 295 }
 296
 297 /* Returns a string of characters for NAME.  */
 298
 299 static inline const char *
 300 clast_name_to_str (clast_name_p name)
 301 {
 302   gcc_assert (name->type == clast_expr_name);
 303   return ((const struct clast_name*) name)->name;
 304 }
 305
 306 #endif /* CLOOG_ORG  */
 307 #endif /* GRAPHITE_CLOOG_COMPAT_H  */