polly/lib/Support/GICHelper.cpp

   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.getSignificantBits() < A.getBitWidth())
  78     A = A.trunc(A.getSignificantBits());
  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
  87 stringFromIslObjInternal(__isl_keep ISLTy *isl_obj,
  88                          ISL_CTX_GETTER ctx_getter_fn, ISL_PRINTER printer_fn,
  89                          const std::string &DefaultValue) {
  90   if (!isl_obj)
  91     return DefaultValue;
  92   isl_ctx *ctx = ctx_getter_fn(isl_obj);
  93   isl_printer *p = isl_printer_to_str(ctx);
  94   p = printer_fn(p, isl_obj);
  95   char *char_str = isl_printer_get_str(p);
  96   std::string string;
  97   if (char_str)
  98     string = char_str;
  99   else
 100     string = DefaultValue;
 101   free(char_str);
 102   isl_printer_free(p);
 103   return string;
 104 }
 105
 106 #define ISL_C_OBJECT_TO_STRING(name)                                           \
 107   std::string polly::stringFromIslObj(__isl_keep isl_##name *Obj,              \
 108                                       std::string DefaultValue) {              \
 109     return stringFromIslObjInternal(Obj, isl_##name##_get_ctx,                 \
 110                                     isl_printer_print_##name, DefaultValue);   \
 111   }
 112
 113 ISL_C_OBJECT_TO_STRING(aff)
 114 ISL_C_OBJECT_TO_STRING(ast_expr)
 115 ISL_C_OBJECT_TO_STRING(ast_node)
 116 ISL_C_OBJECT_TO_STRING(basic_map)
 117 ISL_C_OBJECT_TO_STRING(basic_set)
 118 ISL_C_OBJECT_TO_STRING(map)
 119 ISL_C_OBJECT_TO_STRING(set)
 120 ISL_C_OBJECT_TO_STRING(id)
 121 ISL_C_OBJECT_TO_STRING(multi_aff)
 122 ISL_C_OBJECT_TO_STRING(multi_pw_aff)
 123 ISL_C_OBJECT_TO_STRING(multi_union_pw_aff)
 124 ISL_C_OBJECT_TO_STRING(point)
 125 ISL_C_OBJECT_TO_STRING(pw_aff)
 126 ISL_C_OBJECT_TO_STRING(pw_multi_aff)
 127 ISL_C_OBJECT_TO_STRING(schedule)
 128 ISL_C_OBJECT_TO_STRING(schedule_node)
 129 ISL_C_OBJECT_TO_STRING(space)
 130 ISL_C_OBJECT_TO_STRING(union_access_info)
 131 ISL_C_OBJECT_TO_STRING(union_flow)
 132 ISL_C_OBJECT_TO_STRING(union_set)
 133 ISL_C_OBJECT_TO_STRING(union_map)
 134 ISL_C_OBJECT_TO_STRING(union_pw_aff)
 135 ISL_C_OBJECT_TO_STRING(union_pw_multi_aff)
 136
 137 static void replace(std::string &str, StringRef find, StringRef replace) {
 138   size_t pos = 0;
 139   while ((pos = str.find(find, pos)) != std::string::npos) {
 140     str.replace(pos, find.size(), replace);
 141     pos += replace.size();
 142   }
 143 }
 144
 145 static void makeIslCompatible(std::string &str) {
 146   llvm::replace(str, '.', '_');
 147   llvm::replace(str, '\"', '_');
 148   replace(str, StringRef(" "), StringRef("__"));
 149   replace(str, StringRef("=>"), StringRef("TO"));
 150   llvm::replace(str, '+', '_');
 151 }
 152
 153 std::string polly::getIslCompatibleName(const std::string &Prefix,
 154                                         const std::string &Middle,
 155                                         const std::string &Suffix) {
 156   std::string S = Prefix + Middle + Suffix;
 157   makeIslCompatible(S);
 158   return S;
 159 }
 160
 161 std::string polly::getIslCompatibleName(const std::string &Prefix,
 162                                         const std::string &Name, long Number,
 163                                         const std::string &Suffix,
 164                                         bool UseInstructionNames) {
 165   std::string S = Prefix;
 166
 167   if (UseInstructionNames)
 168     S += std::string("_") + Name;
 169   else
 170     S += std::to_string(Number);
 171
 172   S += Suffix;
 173
 174   makeIslCompatible(S);
 175   return S;
 176 }
 177
 178 std::string polly::getIslCompatibleName(const std::string &Prefix,
 179                                         const Value *Val, long Number,
 180                                         const std::string &Suffix,
 181                                         bool UseInstructionNames) {
 182   std::string ValStr;
 183
 184   if (UseInstructionNames && Val->hasName())
 185     ValStr = std::string("_") + std::string(Val->getName());
 186   else
 187     ValStr = std::to_string(Number);
 188
 189   return getIslCompatibleName(Prefix, ValStr, Suffix);
 190 }
 191
 192 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 193 #define ISL_DUMP_OBJECT_IMPL(NAME)                                             \
 194   void polly::dumpIslObj(const isl::NAME &Obj) {                               \
 195     isl_##NAME##_dump(Obj.get());                                              \
 196   }                                                                            \
 197   void polly::dumpIslObj(isl_##NAME *Obj) { isl_##NAME##_dump(Obj); }
 198
 199 ISL_DUMP_OBJECT_IMPL(aff)
 200 ISL_DUMP_OBJECT_IMPL(aff_list)
 201 ISL_DUMP_OBJECT_IMPL(ast_expr)
 202 ISL_DUMP_OBJECT_IMPL(ast_node)
 203 ISL_DUMP_OBJECT_IMPL(ast_node_list)
 204 ISL_DUMP_OBJECT_IMPL(basic_map)
 205 ISL_DUMP_OBJECT_IMPL(basic_map_list)
 206 ISL_DUMP_OBJECT_IMPL(basic_set)
 207 ISL_DUMP_OBJECT_IMPL(basic_set_list)
 208 ISL_DUMP_OBJECT_IMPL(constraint)
 209 ISL_DUMP_OBJECT_IMPL(id)
 210 ISL_DUMP_OBJECT_IMPL(id_list)
 211 ISL_DUMP_OBJECT_IMPL(id_to_ast_expr)
 212 ISL_DUMP_OBJECT_IMPL(local_space)
 213 ISL_DUMP_OBJECT_IMPL(map)
 214 ISL_DUMP_OBJECT_IMPL(map_list)
 215 ISL_DUMP_OBJECT_IMPL(multi_aff)
 216 ISL_DUMP_OBJECT_IMPL(multi_pw_aff)
 217 ISL_DUMP_OBJECT_IMPL(multi_union_pw_aff)
 218 ISL_DUMP_OBJECT_IMPL(multi_val)
 219 ISL_DUMP_OBJECT_IMPL(point)
 220 ISL_DUMP_OBJECT_IMPL(pw_aff)
 221 ISL_DUMP_OBJECT_IMPL(pw_aff_list)
 222 ISL_DUMP_OBJECT_IMPL(pw_multi_aff)
 223 ISL_DUMP_OBJECT_IMPL(schedule)
 224 ISL_DUMP_OBJECT_IMPL(schedule_constraints)
 225 ISL_DUMP_OBJECT_IMPL(schedule_node)
 226 ISL_DUMP_OBJECT_IMPL(set)
 227 ISL_DUMP_OBJECT_IMPL(set_list)
 228 ISL_DUMP_OBJECT_IMPL(space)
 229 ISL_DUMP_OBJECT_IMPL(union_map)
 230 ISL_DUMP_OBJECT_IMPL(union_pw_aff)
 231 ISL_DUMP_OBJECT_IMPL(union_pw_aff_list)
 232 ISL_DUMP_OBJECT_IMPL(union_pw_multi_aff)
 233 ISL_DUMP_OBJECT_IMPL(union_set)
 234 ISL_DUMP_OBJECT_IMPL(union_set_list)
 235 ISL_DUMP_OBJECT_IMPL(val)
 236 ISL_DUMP_OBJECT_IMPL(val_list)
 237
 238 void polly::dumpIslObj(__isl_keep isl_schedule_node *node, raw_ostream &OS) {
 239   if (!node)
 240     return;
 241
 242   isl_ctx *ctx = isl_schedule_node_get_ctx(node);
 243   isl_printer *p = isl_printer_to_str(ctx);
 244   p = isl_printer_set_yaml_style(p, ISL_YAML_STYLE_BLOCK);
 245   p = isl_printer_print_schedule_node(p, node);
 246
 247   char *char_str = isl_printer_get_str(p);
 248   OS << char_str;
 249
 250   free(char_str);
 251   isl_printer_free(p);
 252 }
 253
 254 void polly::dumpIslObj(const isl::schedule_node &Node, raw_ostream &OS) {
 255   dumpIslObj(Node.get(), OS);
 256 }
 257
 258 #endif