1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
| //===- Support/GICHelper.h -- Helper functions for ISL --------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Helper functions for isl objects.
//
//===----------------------------------------------------------------------===//
//
#ifndef POLLY_SUPPORT_GIC_HELPER_H
#define POLLY_SUPPORT_GIC_HELPER_H
#include "llvm/ADT/APInt.h"
#include "llvm/IR/DiagnosticInfo.h"
#include "llvm/Support/raw_ostream.h"
#include "isl/ctx.h"
#include "isl/isl-noexceptions.h"
#include "isl/options.h"
namespace polly {
/// Translate an llvm::APInt to an isl_val.
///
/// Translate the bitsequence without sign information as provided by APInt into
/// a signed isl_val type. Depending on the value of @p IsSigned @p Int is
/// interpreted as unsigned value or as signed value in two's complement
/// representation.
///
/// Input IsSigned Output
///
/// 0 0 -> 0
/// 1 0 -> 1
/// 00 0 -> 0
/// 01 0 -> 1
/// 10 0 -> 2
/// 11 0 -> 3
///
/// 0 1 -> 0
/// 1 1 -> -1
/// 00 1 -> 0
/// 01 1 -> 1
/// 10 1 -> -2
/// 11 1 -> -1
///
/// @param Ctx The isl_ctx to create the isl_val in.
/// @param Int The integer value to translate.
/// @param IsSigned If the APInt should be interpreted as signed or unsigned
/// value.
///
/// @return The isl_val corresponding to @p Int.
__isl_give isl_val *isl_valFromAPInt(isl_ctx *Ctx, const llvm::APInt Int,
bool IsSigned);
/// Translate an llvm::APInt to an isl::val.
///
/// Translate the bitsequence without sign information as provided by APInt into
/// a signed isl::val type. Depending on the value of @p IsSigned @p Int is
/// interpreted as unsigned value or as signed value in two's complement
/// representation.
///
/// Input IsSigned Output
///
/// 0 0 -> 0
/// 1 0 -> 1
/// 00 0 -> 0
/// 01 0 -> 1
/// 10 0 -> 2
/// 11 0 -> 3
///
/// 0 1 -> 0
/// 1 1 -> -1
/// 00 1 -> 0
/// 01 1 -> 1
/// 10 1 -> -2
/// 11 1 -> -1
///
/// @param Ctx The isl_ctx to create the isl::val in.
/// @param Int The integer value to translate.
/// @param IsSigned If the APInt should be interpreted as signed or unsigned
/// value.
///
/// @return The isl::val corresponding to @p Int.
inline isl::val valFromAPInt(isl_ctx *Ctx, const llvm::APInt Int,
bool IsSigned) {
return isl::manage(isl_valFromAPInt(Ctx, Int, IsSigned));
}
/// Translate isl_val to llvm::APInt.
///
/// This function can only be called on isl_val values which are integers.
/// Calling this function with a non-integral rational, NaN or infinity value
/// is not allowed.
///
/// As the input isl_val may be negative, the APInt that this function returns
/// must always be interpreted as signed two's complement value. The bitwidth of
/// the generated APInt is always the minimal bitwidth necessary to model the
/// provided integer when interpreting the bit pattern as signed value.
///
/// Some example conversions are:
///
/// Input Bits Signed Bitwidth
/// 0 -> 0 0 1
/// -1 -> 1 -1 1
/// 1 -> 01 1 2
/// -2 -> 10 -2 2
/// 2 -> 010 2 3
/// -3 -> 101 -3 3
/// 3 -> 011 3 3
/// -4 -> 100 -4 3
/// 4 -> 0100 4 4
///
/// @param Val The isl val to translate.
///
/// @return The APInt value corresponding to @p Val.
llvm::APInt APIntFromVal(__isl_take isl_val *Val);
/// Translate isl::val to llvm::APInt.
///
/// This function can only be called on isl::val values which are integers.
/// Calling this function with a non-integral rational, NaN or infinity value
/// is not allowed.
///
/// As the input isl::val may be negative, the APInt that this function returns
/// must always be interpreted as signed two's complement value. The bitwidth of
/// the generated APInt is always the minimal bitwidth necessary to model the
/// provided integer when interpreting the bit pattern as signed value.
///
/// Some example conversions are:
///
/// Input Bits Signed Bitwidth
/// 0 -> 0 0 1
/// -1 -> 1 -1 1
/// 1 -> 01 1 2
/// -2 -> 10 -2 2
/// 2 -> 010 2 3
/// -3 -> 101 -3 3
/// 3 -> 011 3 3
/// -4 -> 100 -4 3
/// 4 -> 0100 4 4
///
/// @param Val The isl val to translate.
///
/// @return The APInt value corresponding to @p Val.
inline llvm::APInt APIntFromVal(isl::val V) {
return APIntFromVal(V.release());
}
/// Get c++ string from Isl objects.
//@{
std::string stringFromIslObj(__isl_keep isl_map *map);
std::string stringFromIslObj(__isl_keep isl_union_map *umap);
std::string stringFromIslObj(__isl_keep isl_set *set);
std::string stringFromIslObj(__isl_keep isl_union_set *uset);
std::string stringFromIslObj(__isl_keep isl_schedule *schedule);
std::string stringFromIslObj(__isl_keep isl_multi_aff *maff);
std::string stringFromIslObj(__isl_keep isl_pw_multi_aff *pma);
std::string stringFromIslObj(__isl_keep isl_multi_pw_aff *mpa);
std::string stringFromIslObj(__isl_keep isl_union_pw_multi_aff *upma);
std::string stringFromIslObj(__isl_keep isl_aff *aff);
std::string stringFromIslObj(__isl_keep isl_pw_aff *pwaff);
std::string stringFromIslObj(__isl_keep isl_space *space);
//@}
inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
__isl_keep isl_union_map *Map) {
OS << polly::stringFromIslObj(Map);
return OS;
}
inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
__isl_keep isl_map *Map) {
OS << polly::stringFromIslObj(Map);
return OS;
}
inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
__isl_keep isl_set *Set) {
OS << polly::stringFromIslObj(Set);
return OS;
}
inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
__isl_keep isl_pw_aff *Map) {
OS << polly::stringFromIslObj(Map);
return OS;
}
inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
__isl_keep isl_pw_multi_aff *PMA) {
OS << polly::stringFromIslObj(PMA);
return OS;
}
inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
__isl_keep isl_multi_aff *MA) {
OS << polly::stringFromIslObj(MA);
return OS;
}
inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
__isl_keep isl_union_pw_multi_aff *UPMA) {
OS << polly::stringFromIslObj(UPMA);
return OS;
}
inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
__isl_keep isl_schedule *Schedule) {
OS << polly::stringFromIslObj(Schedule);
return OS;
}
inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
__isl_keep isl_space *Space) {
OS << polly::stringFromIslObj(Space);
return OS;
}
/// Combine Prefix, Val (or Number) and Suffix to an isl-compatible name.
///
/// In case @p UseInstructionNames is set, this function returns:
///
/// @p Prefix + "_" + @p Val->getName() + @p Suffix
///
/// otherwise
///
/// @p Prefix + to_string(Number) + @p Suffix
///
/// We ignore the value names by default, as they may change between release
/// and debug mode and can consequently not be used when aiming for reproducible
/// builds. However, for debugging named statements are often helpful, hence
/// we allow their optional use.
std::string getIslCompatibleName(const std::string &Prefix,
const llvm::Value *Val, long Number,
const std::string &Suffix,
bool UseInstructionNames);
/// Combine Prefix, Name (or Number) and Suffix to an isl-compatible name.
///
/// In case @p UseInstructionNames is set, this function returns:
///
/// @p Prefix + "_" + Name + @p Suffix
///
/// otherwise
///
/// @p Prefix + to_string(Number) + @p Suffix
///
/// We ignore @p Name by default, as they may change between release
/// and debug mode and can consequently not be used when aiming for reproducible
/// builds. However, for debugging named statements are often helpful, hence
/// we allow their optional use.
std::string getIslCompatibleName(const std::string &Prefix,
const std::string &Middle, long Number,
const std::string &Suffix,
bool UseInstructionNames);
std::string getIslCompatibleName(const std::string &Prefix,
const std::string &Middle,
const std::string &Suffix);
inline llvm::DiagnosticInfoOptimizationBase &
operator<<(llvm::DiagnosticInfoOptimizationBase &OS,
const isl::union_map &Obj) {
OS << Obj.to_str();
return OS;
}
/// Scope guard for code that allows arbitrary isl function to return an error
/// if the max-operations quota exceeds.
///
/// This allows to opt-in code sections that have known long executions times.
/// code not in a hot path can continue to assume that no unexpected error
/// occurs.
///
/// This is typically used inside a nested IslMaxOperationsGuard scope. The
/// IslMaxOperationsGuard defines the number of allowed base operations for some
/// code, IslQuotaScope defines where it is allowed to return an error result.
class IslQuotaScope {
isl_ctx *IslCtx;
int OldOnError;
public:
IslQuotaScope() : IslCtx(nullptr) {}
IslQuotaScope(const IslQuotaScope &) = delete;
IslQuotaScope(IslQuotaScope &&Other)
: IslCtx(Other.IslCtx), OldOnError(Other.OldOnError) {
Other.IslCtx = nullptr;
}
const IslQuotaScope &operator=(IslQuotaScope &&Other) {
std::swap(this->IslCtx, Other.IslCtx);
std::swap(this->OldOnError, Other.OldOnError);
return *this;
}
/// Enter a quota-aware scope.
///
/// Should not be used directly. Use IslMaxOperationsGuard::enter() instead.
explicit IslQuotaScope(isl_ctx *IslCtx, unsigned long LocalMaxOps)
: IslCtx(IslCtx) {
assert(IslCtx);
assert(isl_ctx_get_max_operations(IslCtx) == 0 && "Incorrect nesting");
if (LocalMaxOps == 0) {
this->IslCtx = nullptr;
return;
}
OldOnError = isl_options_get_on_error(IslCtx);
isl_options_set_on_error(IslCtx, ISL_ON_ERROR_CONTINUE);
isl_ctx_reset_error(IslCtx);
isl_ctx_set_max_operations(IslCtx, LocalMaxOps);
}
~IslQuotaScope() {
if (!IslCtx)
return;
assert(isl_ctx_get_max_operations(IslCtx) > 0 && "Incorrect nesting");
assert(isl_options_get_on_error(IslCtx) == ISL_ON_ERROR_CONTINUE &&
"Incorrect nesting");
isl_ctx_set_max_operations(IslCtx, 0);
isl_options_set_on_error(IslCtx, OldOnError);
}
/// Return whether the current quota has exceeded.
bool hasQuotaExceeded() const {
if (!IslCtx)
return false;
return isl_ctx_last_error(IslCtx) == isl_error_quota;
}
};
/// Scoped limit of ISL operations.
///
/// Limits the number of ISL operations during the lifetime of this object. The
/// idea is to use this as an RAII guard for the scope where the code is aware
/// that ISL can return errors even when all input is valid. After leaving the
/// scope, it will return to the error setting as it was before. That also means
/// that the error setting should not be changed while in that scope.
///
/// Such scopes are not allowed to be nested because the previous operations
/// counter cannot be reset to the previous state, or one that adds the
/// operations while being in the nested scope. Use therefore is only allowed
/// while currently a no operations-limit is active.
class IslMaxOperationsGuard {
private:
/// The ISL context to set the operations limit.
///
/// If set to nullptr, there is no need for any action at the end of the
/// scope.
isl_ctx *IslCtx;
/// Maximum number of operations for the scope.
unsigned long LocalMaxOps;
/// When AutoEnter is enabled, holds the IslQuotaScope object.
IslQuotaScope TopLevelScope;
public:
/// Enter a max operations scope.
///
/// @param IslCtx The ISL context to set the operations limit for.
/// @param LocalMaxOps Maximum number of operations allowed in the
/// scope. If set to zero, no operations limit is enforced.
/// @param AutoEnter If true, automatically enters an IslQuotaScope such
/// that isl operations may return quota errors
/// immediately. If false, only starts the operations
/// counter, but isl does not return quota errors before
/// calling enter().
IslMaxOperationsGuard(isl_ctx *IslCtx, unsigned long LocalMaxOps,
bool AutoEnter = true)
: IslCtx(IslCtx), LocalMaxOps(LocalMaxOps) {
assert(IslCtx);
assert(isl_ctx_get_max_operations(IslCtx) == 0 &&
"Nested max operations not supported");
// Users of this guard may check whether the last error was isl_error_quota.
// Reset the last error such that a previous out-of-quota error is not
// mistaken to have occurred in the in this quota, even if the max number of
// operations is set to infinite (LocalMaxOps == 0).
isl_ctx_reset_error(IslCtx);
if (LocalMaxOps == 0) {
// No limit on operations; also disable restoring on_error/max_operations.
this->IslCtx = nullptr;
return;
}
isl_ctx_reset_operations(IslCtx);
TopLevelScope = enter(AutoEnter);
}
/// Enter a scope that can handle out-of-quota errors.
///
/// @param AllowReturnNull Whether the scoped code can handle out-of-quota
/// errors. If false, returns a dummy scope object that
/// does nothing.
IslQuotaScope enter(bool AllowReturnNull = true) {
return AllowReturnNull && IslCtx ? IslQuotaScope(IslCtx, LocalMaxOps)
: IslQuotaScope();
}
/// Return whether the current quota has exceeded.
bool hasQuotaExceeded() const {
if (!IslCtx)
return false;
return isl_ctx_last_error(IslCtx) == isl_error_quota;
}
};
} // end namespace polly
#endif
|