1
2   /**-------------------------------------------------------------------**
3    **                               CLooG                               **
4    **-------------------------------------------------------------------**
5    **                             domain.h                              **
6    **-------------------------------------------------------------------**
7    **                  First version: october 28th 2001                 **
8    **-------------------------------------------------------------------**/
9
10
11/******************************************************************************
12 *               CLooG : the Chunky Loop Generator (experimental)             *
13 ******************************************************************************
14 *                                                                            *
15 * Copyright (C) 2001-2005 Cedric Bastoul                                     *
16 *                                                                            *
17 * This library is free software; you can redistribute it and/or              *
18 * modify it under the terms of the GNU Lesser General Public                 *
19 * License as published by the Free Software Foundation; either               *
20 * version 2.1 of the License, or (at your option) any later version.         *
21 *                                                                            *
22 * This library is distributed in the hope that it will be useful,            *
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU          *
25 * Lesser General Public License for more details.                            *
26 *                                                                            *
27 * You should have received a copy of the GNU Lesser General Public           *
28 * License along with this library; if not, write to the Free Software        *
29 * Foundation, Inc., 51 Franklin Street, Fifth Floor,                         *
30 * Boston, MA  02110-1301  USA                                                *
31 *                                                                            *
32 * CLooG, the Chunky Loop Generator                                           *
33 * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr                         *
34 *                                                                            *
35 ******************************************************************************/
36
37
38#ifndef CLOOG_DOMAIN_H
39#define CLOOG_DOMAIN_H
40#if defined(__cplusplus)
41extern "C"
42  {
43#endif
44
45
46struct cloogdomain;
47typedef struct cloogdomain CloogDomain ;
48struct cloogscattering;
49typedef struct cloogscattering CloogScattering;
50struct osl_relation;
51
52
53/**
54 * CloogDomainList structure:
55 * this structure reprensents a node of a linked list of CloogDomain structures.
56 */
57struct cloogdomainlist {
58  CloogDomain *domain;         /**< An element of the list. */
59  struct cloogdomainlist *next;/**< Pointer to the next element of the list.*/
60} ;
61typedef struct cloogdomainlist CloogDomainList;
62
63
64/**
65 * CloogScatteringList structure:
66 * this structure reprensents a node of a linked list of CloogScattering structures.
67 */
68struct cloogscatteringlist {
69  CloogScattering *scatt;          /**< An element of the list. */
70  struct cloogscatteringlist *next;/**< Pointer to the next element of the list.*/
71} ;
72typedef struct cloogscatteringlist CloogScatteringList;
73
74
75/******************************************************************************
76 *                              PolyLib interface                             *
77 ******************************************************************************/
78void          cloog_domain_print_constraints(FILE *, CloogDomain *,
79						int print_number);
80void          cloog_scattering_print_constraints(FILE *, CloogScattering *);
81void          cloog_domain_free(CloogDomain *) ;
82void          cloog_scattering_free(CloogScattering *);
83CloogDomain * cloog_domain_copy(CloogDomain *) ;
84CloogDomain * cloog_domain_convex(CloogDomain * Pol) ;
85CloogDomain * cloog_domain_simple_convex(CloogDomain * domain);
86CloogDomain * cloog_domain_simplify(CloogDomain *, CloogDomain *) ;
87CloogDomain * cloog_domain_union(CloogDomain *, CloogDomain *) ;
88CloogDomain * cloog_domain_intersection(CloogDomain *, CloogDomain *) ;
89CloogDomain * cloog_domain_difference(CloogDomain *, CloogDomain *) ;
90void          cloog_domain_sort(CloogDomain**,unsigned,unsigned,int *);
91int cloog_domain_follows(CloogDomain *dom1, CloogDomain *dom2, unsigned level);
92CloogDomain * cloog_domain_empty(CloogDomain *model);
93int cloog_domain_is_bounded(CloogDomain *dim, unsigned level);
94CloogDomain *cloog_domain_bound_splitter(CloogDomain *dom, int level);
95
96
97/******************************************************************************
98 *                          Structure display function                        *
99 ******************************************************************************/
100void cloog_domain_print_structure(FILE *file, CloogDomain *domain, int level,
101				  const char *name);
102
103
104/******************************************************************************
105 *                         Memory deallocation function                       *
106 ******************************************************************************/
107void cloog_domain_list_free(CloogDomainList *);
108void cloog_scattering_list_free(CloogScatteringList *);
109
110
111/*+****************************************************************************
112 *                               Reading function                             *
113 ******************************************************************************/
114CloogDomain * cloog_domain_read_context(CloogState *state, FILE * foo);
115CloogDomain * cloog_domain_union_read(CloogState *state, FILE *foo, int nb_par);
116CloogScattering *cloog_domain_read_scattering(CloogDomain *domain, FILE *foo);
117
118CloogDomain * cloog_domain_from_cloog_matrix(CloogState *state,
119				CloogMatrix *matrix, int nb_par);
120CloogScattering * cloog_scattering_from_cloog_matrix(CloogState *state,
121				CloogMatrix *matrix, int nb_scat, int nb_par);
122
123
124/******************************************************************************
125 *                            Processing functions                            *
126 ******************************************************************************/
127CloogDomain *cloog_domain_from_osl_relation(CloogState *,
128                                            struct osl_relation *);
129CloogScattering *cloog_scattering_from_osl_relation(CloogState *,
130                                                    struct osl_relation *);
131CloogConstraintSet *cloog_domain_constraints(CloogDomain *);
132int           cloog_domain_isempty(CloogDomain *) ;
133CloogDomain * cloog_domain_universe(CloogState *state, unsigned dim);
134CloogDomain * cloog_domain_project(CloogDomain *, int);
135CloogDomain * cloog_domain_extend(CloogDomain *, int);
136int           cloog_domain_never_integral(CloogDomain *) ;
137void          cloog_domain_stride(CloogDomain *, int, cloog_int_t *, cloog_int_t *);
138int           cloog_domain_can_stride(CloogDomain *domain, int level);
139int           cloog_domain_is_otl(CloogDomain *domain, int level);
140CloogDomain * cloog_domain_stride_lower_bound(CloogDomain *domain, int level,
141					CloogStride *stride);
142CloogDomain * cloog_domain_add_stride_constraint(CloogDomain *domain,
143					CloogStride *stride);
144int           cloog_domain_can_unroll(CloogDomain *domain, int level,
145				cloog_int_t *n, CloogConstraint **lb);
146CloogDomain * cloog_domain_fixed_offset(CloogDomain *domain, int level,
147				CloogConstraint *lb, cloog_int_t offset);
148int           cloog_domain_lazy_disjoint(CloogDomain *, CloogDomain *) ;
149int           cloog_domain_lazy_equal(CloogDomain *, CloogDomain *) ;
150int           cloog_scattering_lazy_block(CloogScattering *, CloogScattering *,
151                                      CloogScatteringList *, int);
152int           cloog_scattering_lazy_isscalar(CloogScattering *, int,
153								cloog_int_t *);
154int           cloog_domain_lazy_isconstant(CloogDomain *domain, int dimension,
155					   cloog_int_t *value);
156int           cloog_scattering_list_lazy_same(CloogScatteringList *);
157CloogDomain * cloog_domain_cut_first(CloogDomain *domain, CloogDomain **rest);
158CloogDomain * cloog_domain_simplify_union(CloogDomain *domain);
159CloogScattering * cloog_scattering_erase_dimension(CloogScattering *, int);
160
161int           cloog_domain_dimension(CloogDomain *) ;
162int           cloog_domain_parameter_dimension(CloogDomain *domain);
163int           cloog_scattering_dimension(CloogScattering *, CloogDomain *);
164int           cloog_domain_isconvex(CloogDomain *) ;
165CloogDomain * cloog_domain_cube(CloogState *state,
166				int dim, cloog_int_t min, cloog_int_t max);
167CloogDomain * cloog_domain_from_context(CloogDomain *context);
168CloogDomain * cloog_domain_scatter(CloogDomain *domain, CloogScattering *scatt);
169int           cloog_scattering_fully_specified(CloogScattering *scattering,
170						CloogDomain *domain);
171
172CloogStride *cloog_domain_list_stride(CloogDomainList *list, int level);
173
174#if defined(__cplusplus)
175  }
176#endif
177#endif /* define _H */
178