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 #else
  29 typedef const char *clast_name_p;
  30 #endif
  31
  32 #ifndef CLOOG_ORG
  33
  34 /* CloogOptions compatibility.  */
  35 #define build_cloog_prog(SCOP, PROG, OPT, STATE)\
  36   build_cloog_prog (SCOP, PROG, STATE)
  37 #define cloog_program_extract_scalars(PROG, SCATT, OPT)\
  38   cloog_program_extract_scalars (PROG, SCATT)
  39 #define cloog_program_scatter(PROG, SCATT, OPT)\
  40   cloog_program_scatter (PROG, SCATT)
  41
  42 /* CLAST compatibility.  */
  43 #define clast_expr_term expr_term
  44 #define clast_expr_red expr_red
  45 #define clast_expr_bin expr_bin
  46 #define clast_pprint pprint
  47
  48 /* CloogState compatibility.  */
  49 #define CloogState void
  50 #define cloog_state_malloc() NULL
  51 #define cloog_state_free(STATE)
  52 #define cloog_loop_malloc(STATE) cloog_loop_malloc ()
  53 #define cloog_options_malloc(STATE) cloog_options_malloc ()
  54 #define cloog_statement_alloc(STATE, INDEX) cloog_statement_alloc (INDEX)
  55 #define new_Cloog_Domain_from_ppl_Pointset_Powerset(PSPS, NB, STATE)\
  56   new_Cloog_Domain_from_ppl_Pointset_Powerset (PSPS)
  57 #define new_Cloog_Domain_from_ppl_Polyhedron(POLY, NB, STATE)\
  58   new_Cloog_Domain_from_ppl_Polyhedron (POLY)
  59 #define cloog_domain_from_cloog_matrix(STATE, MAT, NB)\
  60   cloog_domain_matrix2domain (MAT)
  61 #endif
  62
  63 /* Adapt CLooG accessors from CLooG legacy to
  64    newer CLooG versions.  */
  65
  66 #ifdef CLOOG_ORG
  67
  68 static inline void *
  69 cloog_statement_usr (CloogStatement *cs)
  70 {
  71   return cs->usr;
  72 }
  73
  74 static inline CloogDomain *
  75 cloog_domain (CloogDomainList *dl)
  76 {
  77   return dl->domain;
  78 }
  79
  80 static inline void
  81 cloog_set_domain (CloogDomainList *dl, CloogDomain *domain)
  82 {
  83   dl->domain = domain;
  84 }
  85
  86 static inline CloogDomainList *
  87 cloog_next_domain (CloogDomainList *dl)
  88 {
  89   return dl->next;
  90 }
  91
  92 static inline void
  93 cloog_set_next_domain (CloogDomainList *dl, CloogDomainList *next)
  94 {
  95   dl->next = next;
  96 }
  97
  98 static inline int
  99 cloog_program_nb_scattdims (CloogProgram *prog)
 100 {
 101   return prog->nb_scattdims;
 102 }
 103
 104 static inline void
 105 cloog_program_set_nb_scattdims (CloogProgram *prog, int nb_scattdims)
 106 {
 107   prog->nb_scattdims = nb_scattdims;
 108 }
 109
 110 static inline CloogNames *
 111 cloog_program_names (CloogProgram *prog)
 112 {
 113   return prog->names;
 114 }
 115
 116 static inline void
 117 cloog_program_set_names (CloogProgram *prog, CloogNames *names)
 118 {
 119   prog->names = names;
 120 }
 121
 122 static inline void
 123 cloog_program_set_context (CloogProgram *prog, CloogDomain *domain)
 124 {
 125   prog->context = domain;
 126 }
 127
 128 static inline void
 129 cloog_program_set_loop (CloogProgram *prog, CloogLoop *loop)
 130 {
 131   prog->loop = loop;
 132 }
 133
 134 static inline CloogBlockList *
 135 cloog_program_blocklist (CloogProgram *prog)
 136 {
 137   return prog->blocklist;
 138 }
 139
 140 static inline void
 141 cloog_program_set_blocklist (CloogProgram *prog, CloogBlockList *bl)
 142 {
 143   prog->blocklist = bl;
 144 }
 145
 146 static inline int *
 147 cloog_program_scaldims (CloogProgram *prog)
 148 {
 149   return prog->scaldims;
 150 }
 151
 152 static inline void
 153 cloog_program_set_scaldims (CloogProgram *prog, int *s)
 154 {
 155   prog->scaldims = s;
 156 }
 157
 158 static inline int
 159 cloog_names_nb_parameters (CloogNames *names)
 160 {
 161   return names->nb_parameters;
 162 }
 163
 164 static inline void
 165 cloog_names_set_nb_parameters (CloogNames *names, int nb_parameters)
 166 {
 167   names->nb_parameters = nb_parameters;
 168 }
 169
 170 static inline char **
 171 cloog_names_parameters (CloogNames *names)
 172 {
 173   return names->parameters;
 174 }
 175
 176 static inline void
 177 cloog_names_set_parameters (CloogNames *names, char **parameters)
 178 {
 179   names->parameters = parameters;
 180 }
 181
 182 static inline void
 183 cloog_names_set_nb_iterators (CloogNames *names, int nb_iterators)
 184 {
 185   names->nb_iterators = nb_iterators;
 186 }
 187
 188 static inline void
 189 cloog_names_set_iterators (CloogNames *names, char **iterators)
 190 {
 191   names->iterators = iterators;
 192 }
 193
 194 static inline void
 195 cloog_names_set_nb_scattering (CloogNames *names, int nb_scattering)
 196 {
 197   names->nb_scattering = nb_scattering;
 198 }
 199
 200 static inline void
 201 cloog_names_set_scattering (CloogNames *names, char **scattering)
 202 {
 203   names->scattering = scattering;
 204 }
 205
 206 static inline void
 207 cloog_statement_set_usr (CloogStatement *cs, void *u)
 208 {
 209   cs->usr = u;
 210 }
 211
 212 static inline void
 213 cloog_loop_set_next (CloogLoop *loop, CloogLoop *next)
 214 {
 215   loop->next = next;
 216 }
 217
 218 static inline void
 219 cloog_loop_set_domain (CloogLoop *loop, CloogDomain *domain)
 220 {
 221   loop->domain = domain;
 222 }
 223
 224 static inline void
 225 cloog_loop_set_block (CloogLoop *loop, CloogBlock *block)
 226 {
 227   loop->block = block;
 228 }
 229
 230 static inline CloogBlockList *
 231 cloog_block_list_next (CloogBlockList *bl)
 232 {
 233   return bl->next;
 234 }
 235
 236 static inline void
 237 cloog_block_list_set_next (CloogBlockList *bl, CloogBlockList *next)
 238 {
 239   bl->next = next;
 240 }
 241
 242 static inline void
 243 cloog_block_list_set_block (CloogBlockList *bl, CloogBlock *block)
 244 {
 245   bl->block = block;
 246 }
 247 #endif /* CLOOG_ORG  */
 248 #endif /* GRAPHITE_CLOOG_COMPAT_H  */