1 //===- GmpConv.cpp - Recreate LLVM IR from the Scop. ---------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Functions for converting between gmp objects and llvm::APInt.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "polly/Support/GICHelper.h"
14 #include "llvm/ADT/APInt.h"
15 #include "isl/val.h"
16
17 using namespace llvm;
18
isl_valFromAPInt(isl_ctx * Ctx,const APInt Int,bool IsSigned)19 __isl_give isl_val *polly::isl_valFromAPInt(isl_ctx *Ctx, const APInt Int,
20 bool IsSigned) {
21 APInt Abs;
22 isl_val *v;
23
24 // As isl is interpreting the input always as unsigned value, we need some
25 // additional pre and post processing to import signed values. The approach
26 // we take is to first obtain the absolute value of Int and then negate the
27 // value after it has been imported to isl.
28 //
29 // It should be noted that the smallest integer value represented in two's
30 // complement with a certain amount of bits does not have a corresponding
31 // positive representation in two's complement representation with the same
32 // number of bits. E.g. 110 (-2) does not have a corresponding value for (2).
33 // To ensure that there is always a corresponding value available we first
34 // sign-extend the input by one bit and only then take the absolute value.
35 if (IsSigned)
36 Abs = Int.sext(Int.getBitWidth() + 1).abs();
37 else
38 Abs = Int;
39
40 const uint64_t *Data = Abs.getRawData();
41 unsigned Words = Abs.getNumWords();
42
43 v = isl_val_int_from_chunks(Ctx, Words, sizeof(uint64_t), Data);
44
45 if (IsSigned && Int.isNegative())
46 v = isl_val_neg(v);
47
48 return v;
49 }
50
APIntFromVal(__isl_take isl_val * Val)51 APInt polly::APIntFromVal(__isl_take isl_val *Val) {
52 uint64_t *Data;
53 int NumChunks;
54 const static int ChunkSize = sizeof(uint64_t);
55
56 assert(isl_val_is_int(Val) && "Only integers can be converted to APInt");
57
58 NumChunks = isl_val_n_abs_num_chunks(Val, ChunkSize);
59 Data = (uint64_t *)malloc(NumChunks * ChunkSize);
60 isl_val_get_abs_num_chunks(Val, ChunkSize, Data);
61 int NumBits = CHAR_BIT * ChunkSize * NumChunks;
62 APInt A(NumBits, NumChunks, Data);
63
64 // As isl provides only an interface to obtain data that describes the
65 // absolute value of an isl_val, A at this point always contains a positive
66 // number. In case Val was originally negative, we expand the size of A by
67 // one and negate the value (in two's complement representation). As a result,
68 // the new value in A corresponds now with Val.
69 if (isl_val_is_neg(Val)) {
70 A = A.zext(A.getBitWidth() + 1);
71 A = -A;
72 }
73
74 // isl may represent small numbers with more than the minimal number of bits.
75 // We truncate the APInt to the minimal number of bits needed to represent the
76 // signed value it contains, to ensure that the bitwidth is always minimal.
77 if (A.getMinSignedBits() < A.getBitWidth())
78 A = A.trunc(A.getMinSignedBits());
79
80 free(Data);
81 isl_val_free(Val);
82 return A;
83 }
84
85 template <typename ISLTy, typename ISL_CTX_GETTER, typename ISL_PRINTER>
stringFromIslObjInternal(__isl_keep ISLTy * isl_obj,ISL_CTX_GETTER ctx_getter_fn,ISL_PRINTER printer_fn)86 static inline std::string stringFromIslObjInternal(__isl_keep ISLTy *isl_obj,
87 ISL_CTX_GETTER ctx_getter_fn,
88 ISL_PRINTER printer_fn) {
89 if (!isl_obj)
90 return "null";
91 isl_ctx *ctx = ctx_getter_fn(isl_obj);
92 isl_printer *p = isl_printer_to_str(ctx);
93 p = printer_fn(p, isl_obj);
94 char *char_str = isl_printer_get_str(p);
95 std::string string;
96 if (char_str)
97 string = char_str;
98 else
99 string = "null";
100 free(char_str);
101 isl_printer_free(p);
102 return string;
103 }
104
stringFromIslObj(__isl_keep isl_map * map)105 std::string polly::stringFromIslObj(__isl_keep isl_map *map) {
106 return stringFromIslObjInternal(map, isl_map_get_ctx, isl_printer_print_map);
107 }
108
stringFromIslObj(__isl_keep isl_set * set)109 std::string polly::stringFromIslObj(__isl_keep isl_set *set) {
110 return stringFromIslObjInternal(set, isl_set_get_ctx, isl_printer_print_set);
111 }
112
stringFromIslObj(__isl_keep isl_union_map * umap)113 std::string polly::stringFromIslObj(__isl_keep isl_union_map *umap) {
114 return stringFromIslObjInternal(umap, isl_union_map_get_ctx,
115 isl_printer_print_union_map);
116 }
117
stringFromIslObj(__isl_keep isl_union_set * uset)118 std::string polly::stringFromIslObj(__isl_keep isl_union_set *uset) {
119 return stringFromIslObjInternal(uset, isl_union_set_get_ctx,
120 isl_printer_print_union_set);
121 }
122
stringFromIslObj(__isl_keep isl_schedule * schedule)123 std::string polly::stringFromIslObj(__isl_keep isl_schedule *schedule) {
124 return stringFromIslObjInternal(schedule, isl_schedule_get_ctx,
125 isl_printer_print_schedule);
126 }
127
stringFromIslObj(__isl_keep isl_multi_aff * maff)128 std::string polly::stringFromIslObj(__isl_keep isl_multi_aff *maff) {
129 return stringFromIslObjInternal(maff, isl_multi_aff_get_ctx,
130 isl_printer_print_multi_aff);
131 }
132
stringFromIslObj(__isl_keep isl_pw_multi_aff * pma)133 std::string polly::stringFromIslObj(__isl_keep isl_pw_multi_aff *pma) {
134 return stringFromIslObjInternal(pma, isl_pw_multi_aff_get_ctx,
135 isl_printer_print_pw_multi_aff);
136 }
137
stringFromIslObj(__isl_keep isl_multi_pw_aff * mpa)138 std::string polly::stringFromIslObj(__isl_keep isl_multi_pw_aff *mpa) {
139 return stringFromIslObjInternal(mpa, isl_multi_pw_aff_get_ctx,
140 isl_printer_print_multi_pw_aff);
141 }
142
stringFromIslObj(__isl_keep isl_union_pw_multi_aff * upma)143 std::string polly::stringFromIslObj(__isl_keep isl_union_pw_multi_aff *upma) {
144 return stringFromIslObjInternal(upma, isl_union_pw_multi_aff_get_ctx,
145 isl_printer_print_union_pw_multi_aff);
146 }
147
stringFromIslObj(__isl_keep isl_aff * aff)148 std::string polly::stringFromIslObj(__isl_keep isl_aff *aff) {
149 return stringFromIslObjInternal(aff, isl_aff_get_ctx, isl_printer_print_aff);
150 }
151
stringFromIslObj(__isl_keep isl_pw_aff * pwaff)152 std::string polly::stringFromIslObj(__isl_keep isl_pw_aff *pwaff) {
153 return stringFromIslObjInternal(pwaff, isl_pw_aff_get_ctx,
154 isl_printer_print_pw_aff);
155 }
156
stringFromIslObj(__isl_keep isl_space * space)157 std::string polly::stringFromIslObj(__isl_keep isl_space *space) {
158 return stringFromIslObjInternal(space, isl_space_get_ctx,
159 isl_printer_print_space);
160 }
161
replace(std::string & str,const std::string & find,const std::string & replace)162 static void replace(std::string &str, const std::string &find,
163 const std::string &replace) {
164 size_t pos = 0;
165 while ((pos = str.find(find, pos)) != std::string::npos) {
166 str.replace(pos, find.length(), replace);
167 pos += replace.length();
168 }
169 }
170
makeIslCompatible(std::string & str)171 static void makeIslCompatible(std::string &str) {
172 replace(str, ".", "_");
173 replace(str, "\"", "_");
174 replace(str, " ", "__");
175 replace(str, "=>", "TO");
176 replace(str, "+", "_");
177 }
178
getIslCompatibleName(const std::string & Prefix,const std::string & Middle,const std::string & Suffix)179 std::string polly::getIslCompatibleName(const std::string &Prefix,
180 const std::string &Middle,
181 const std::string &Suffix) {
182 std::string S = Prefix + Middle + Suffix;
183 makeIslCompatible(S);
184 return S;
185 }
186
getIslCompatibleName(const std::string & Prefix,const std::string & Name,long Number,const std::string & Suffix,bool UseInstructionNames)187 std::string polly::getIslCompatibleName(const std::string &Prefix,
188 const std::string &Name, long Number,
189 const std::string &Suffix,
190 bool UseInstructionNames) {
191 std::string S = Prefix;
192
193 if (UseInstructionNames)
194 S += std::string("_") + Name;
195 else
196 S += std::to_string(Number);
197
198 S += Suffix;
199
200 makeIslCompatible(S);
201 return S;
202 }
203
getIslCompatibleName(const std::string & Prefix,const Value * Val,long Number,const std::string & Suffix,bool UseInstructionNames)204 std::string polly::getIslCompatibleName(const std::string &Prefix,
205 const Value *Val, long Number,
206 const std::string &Suffix,
207 bool UseInstructionNames) {
208 std::string ValStr;
209
210 if (UseInstructionNames && Val->hasName())
211 ValStr = std::string("_") + std::string(Val->getName());
212 else
213 ValStr = std::to_string(Number);
214
215 return getIslCompatibleName(Prefix, ValStr, Suffix);
216 }
217
218 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
219 /// To call a inline dump() method in a debugger, at it must have been
220 /// instantiated in at least one translation unit. Because isl's dump() method
221 /// are meant to be called from a debugger only, but not from code, no such
222 /// instantiation would exist. We use this method to force an instantiation in
223 /// this translation unit. Because it has non-static linking, the compiler does
224 /// not know that it is never called, and therefore must ensure the existence of
225 /// the dump functions.
neverCalled()226 void neverCalled() {
227 isl::aff().dump();
228 isl::aff_list().dump();
229 isl::ast_expr().dump();
230 isl::ast_expr_list().dump();
231 isl::ast_node().dump();
232 isl::ast_node_list().dump();
233 isl::basic_map().dump();
234 isl::basic_map_list().dump();
235 isl::basic_set().dump();
236 isl::basic_set_list().dump();
237 isl::constraint().dump();
238 isl::constraint_list().dump();
239 isl::id().dump();
240 isl::id_list().dump();
241 isl::id_to_ast_expr().dump();
242 isl::local_space().dump();
243 isl::map().dump();
244 isl::map_list().dump();
245 isl::multi_aff().dump();
246 isl::multi_pw_aff().dump();
247 isl::multi_union_pw_aff().dump();
248 isl::multi_val().dump();
249 isl::point().dump();
250 isl::pw_aff().dump();
251 isl::pw_aff_list().dump();
252 isl::pw_multi_aff().dump();
253 isl::pw_qpolynomial().dump();
254 isl::qpolynomial().dump();
255 isl::schedule().dump();
256 isl::schedule_constraints().dump();
257 isl::schedule_node().dump();
258 isl::set().dump();
259 isl::set_list().dump();
260 isl::space().dump();
261 isl::union_map().dump();
262 isl::union_map_list().dump();
263 isl::union_pw_aff().dump();
264 isl::union_pw_aff_list().dump();
265 isl::union_pw_multi_aff().dump();
266 isl::union_pw_multi_aff_list().dump();
267 isl::union_set().dump();
268 isl::union_set_list().dump();
269 isl::val().dump();
270 isl::val_list().dump();
271 }
272 #endif
273