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 
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 
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>
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 
105 std::string polly::stringFromIslObj(__isl_keep isl_map *map) {
106   return stringFromIslObjInternal(map, isl_map_get_ctx, isl_printer_print_map);
107 }
108 
109 std::string polly::stringFromIslObj(__isl_keep isl_set *set) {
110   return stringFromIslObjInternal(set, isl_set_get_ctx, isl_printer_print_set);
111 }
112 
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 
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 
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 
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 
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 
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 
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 
148 std::string polly::stringFromIslObj(__isl_keep isl_aff *aff) {
149   return stringFromIslObjInternal(aff, isl_aff_get_ctx, isl_printer_print_aff);
150 }
151 
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 
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 
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 
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 
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 
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 
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.
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