2 /**-------------------------------------------------------------------**
4 **-------------------------------------------------------------------**
6 **-------------------------------------------------------------------**
7 ** First version: october 28th 2001 **
8 **-------------------------------------------------------------------**/
11 /******************************************************************************
12 * CLooG : the Chunky Loop Generator (experimental) *
13 ******************************************************************************
15 * Copyright (C) 2001-2005 Cedric Bastoul *
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. *
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. *
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 *
32 * CLooG, the Chunky Loop Generator *
33 * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
35 ******************************************************************************/
38 #ifndef CLOOG_DOMAIN_H
39 #define CLOOG_DOMAIN_H
40 #if defined(__cplusplus)
47 typedef struct cloogdomain CloogDomain
;
48 struct cloogscattering
;
49 typedef struct cloogscattering CloogScattering
;
53 * CloogDomainList structure:
54 * this structure reprensents a node of a linked list of CloogDomain structures.
56 struct cloogdomainlist
{
57 CloogDomain
*domain
; /**< An element of the list. */
58 struct cloogdomainlist
*next
;/**< Pointer to the next element of the list.*/
60 typedef struct cloogdomainlist CloogDomainList
;
64 * CloogScatteringList structure:
65 * this structure reprensents a node of a linked list of CloogScattering structures.
67 struct cloogscatteringlist
{
68 CloogScattering
*scatt
; /**< An element of the list. */
69 struct cloogscatteringlist
*next
;/**< Pointer to the next element of the list.*/
71 typedef struct cloogscatteringlist CloogScatteringList
;
74 /******************************************************************************
76 ******************************************************************************/
77 void cloog_domain_print_constraints(FILE *, CloogDomain
*,
79 void cloog_scattering_print_constraints(FILE *, CloogScattering
*);
80 void cloog_domain_free(CloogDomain
*) ;
81 void cloog_scattering_free(CloogScattering
*);
82 CloogDomain
* cloog_domain_copy(CloogDomain
*) ;
83 CloogDomain
* cloog_domain_convex(CloogDomain
* Pol
) ;
84 CloogDomain
* cloog_domain_simple_convex(CloogDomain
* domain
);
85 CloogDomain
* cloog_domain_simplify(CloogDomain
*, CloogDomain
*) ;
86 CloogDomain
* cloog_domain_union(CloogDomain
*, CloogDomain
*) ;
87 CloogDomain
* cloog_domain_intersection(CloogDomain
*, CloogDomain
*) ;
88 CloogDomain
* cloog_domain_difference(CloogDomain
*, CloogDomain
*) ;
89 void cloog_domain_sort(CloogDomain
**,unsigned,unsigned,int *);
90 int cloog_domain_follows(CloogDomain
*dom1
, CloogDomain
*dom2
, unsigned level
);
91 CloogDomain
* cloog_domain_empty(CloogDomain
*model
);
92 int cloog_domain_is_bounded(CloogDomain
*dim
, unsigned level
);
93 CloogDomain
*cloog_domain_bound_splitter(CloogDomain
*dom
, int level
);
96 /******************************************************************************
97 * Structure display function *
98 ******************************************************************************/
99 void cloog_domain_print_structure(FILE *file
, CloogDomain
*domain
, int level
,
103 /******************************************************************************
104 * Memory deallocation function *
105 ******************************************************************************/
106 void cloog_domain_list_free(CloogDomainList
*);
107 void cloog_scattering_list_free(CloogScatteringList
*);
110 /*+****************************************************************************
112 ******************************************************************************/
113 CloogDomain
* cloog_domain_read_context(CloogState
*state
, FILE * foo
);
114 CloogDomain
* cloog_domain_union_read(CloogState
*state
, FILE *foo
, int nb_par
);
115 CloogScattering
*cloog_domain_read_scattering(CloogDomain
*domain
, FILE *foo
);
117 CloogDomain
* cloog_domain_from_cloog_matrix(CloogState
*state
,
118 CloogMatrix
*matrix
, int nb_par
);
119 CloogScattering
* cloog_scattering_from_cloog_matrix(CloogState
*state
,
120 CloogMatrix
*matrix
, int nb_scat
, int nb_par
);
123 /******************************************************************************
124 * Processing functions *
125 ******************************************************************************/
126 CloogConstraintSet
*cloog_domain_constraints(CloogDomain
*);
127 int cloog_domain_isempty(CloogDomain
*) ;
128 CloogDomain
* cloog_domain_universe(CloogState
*state
, unsigned dim
);
129 CloogDomain
* cloog_domain_project(CloogDomain
*, int);
130 CloogDomain
* cloog_domain_extend(CloogDomain
*, int);
131 int cloog_domain_never_integral(CloogDomain
*) ;
132 void cloog_domain_stride(CloogDomain
*, int, cloog_int_t
*, cloog_int_t
*);
133 int cloog_domain_can_stride(CloogDomain
*domain
, int level
);
134 int cloog_domain_is_otl(CloogDomain
*domain
, int level
);
135 CloogDomain
* cloog_domain_stride_lower_bound(CloogDomain
*domain
, int level
,
136 CloogStride
*stride
);
137 int cloog_domain_lazy_disjoint(CloogDomain
*, CloogDomain
*) ;
138 int cloog_domain_lazy_equal(CloogDomain
*, CloogDomain
*) ;
139 int cloog_scattering_lazy_block(CloogScattering
*, CloogScattering
*,
140 CloogScatteringList
*, int);
141 int cloog_scattering_lazy_isscalar(CloogScattering
*, int,
143 int cloog_domain_lazy_isconstant(CloogDomain
*domain
, int dimension
,
145 int cloog_scattering_list_lazy_same(CloogScatteringList
*);
146 CloogDomain
* cloog_domain_cut_first(CloogDomain
*domain
, CloogDomain
**rest
);
147 CloogDomain
* cloog_domain_simplify_union(CloogDomain
*domain
);
148 CloogScattering
* cloog_scattering_erase_dimension(CloogScattering
*, int);
150 int cloog_domain_dimension(CloogDomain
*) ;
151 int cloog_domain_parameter_dimension(CloogDomain
*domain
);
152 int cloog_scattering_dimension(CloogScattering
*, CloogDomain
*);
153 int cloog_domain_isconvex(CloogDomain
*) ;
154 CloogDomain
* cloog_domain_cube(CloogState
*state
,
155 int dim
, cloog_int_t min
, cloog_int_t max
);
156 CloogDomain
* cloog_domain_from_context(CloogDomain
*context
);
157 CloogDomain
* cloog_domain_scatter(CloogDomain
*domain
, CloogScattering
*scatt
);
158 int cloog_scattering_fully_specified(CloogScattering
*scattering
,
159 CloogDomain
*domain
);
161 CloogStride
*cloog_domain_list_stride(CloogDomainList
*list
, int level
);
163 #if defined(__cplusplus)
166 #endif /* define _H */