1 //===- IslTest.cpp ----------------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "polly/Support/GICHelper.h" 11 #include "gtest/gtest.h" 12 #include "isl/val.h" 13 14 using namespace llvm; 15 using namespace polly; 16 17 namespace { 18 19 TEST(Isl, APIntToIslVal) { 20 isl_ctx *IslCtx = isl_ctx_alloc(); 21 22 { 23 APInt APZero(1, 0, true); 24 auto *IslZero = isl_valFromAPInt(IslCtx, APZero, true); 25 EXPECT_EQ(isl_bool_true, isl_val_is_zero(IslZero)); 26 isl_val_free(IslZero); 27 } 28 29 { 30 APInt APNOne(1, -1, true); 31 auto *IslNOne = isl_valFromAPInt(IslCtx, APNOne, true); 32 EXPECT_EQ(isl_bool_true, isl_val_is_negone(IslNOne)); 33 isl_val_free(IslNOne); 34 } 35 36 { 37 APInt APZero(1, 0, false); 38 auto *IslZero = isl_valFromAPInt(IslCtx, APZero, false); 39 EXPECT_EQ(isl_bool_true, isl_val_is_zero(IslZero)); 40 isl_val_free(IslZero); 41 } 42 43 { 44 APInt APOne(1, 1, false); 45 auto *IslOne = isl_valFromAPInt(IslCtx, APOne, false); 46 EXPECT_EQ(isl_bool_true, isl_val_is_one(IslOne)); 47 isl_val_free(IslOne); 48 } 49 50 { 51 APInt APNTwo(2, -2, true); 52 auto *IslNTwo = isl_valFromAPInt(IslCtx, APNTwo, true); 53 auto *IslNTwoCmp = isl_val_int_from_si(IslCtx, -2); 54 EXPECT_EQ(isl_bool_true, isl_val_eq(IslNTwo, IslNTwoCmp)); 55 isl_val_free(IslNTwo); 56 isl_val_free(IslNTwoCmp); 57 } 58 59 { 60 APInt APNOne(32, -1, true); 61 auto *IslNOne = isl_valFromAPInt(IslCtx, APNOne, true); 62 EXPECT_EQ(isl_bool_true, isl_val_is_negone(IslNOne)); 63 isl_val_free(IslNOne); 64 } 65 66 { 67 APInt APZero(32, 0, false); 68 auto *IslZero = isl_valFromAPInt(IslCtx, APZero, false); 69 EXPECT_EQ(isl_bool_true, isl_val_is_zero(IslZero)); 70 isl_val_free(IslZero); 71 } 72 73 { 74 APInt APOne(32, 1, false); 75 auto *IslOne = isl_valFromAPInt(IslCtx, APOne, false); 76 EXPECT_EQ(isl_bool_true, isl_val_is_one(IslOne)); 77 isl_val_free(IslOne); 78 } 79 80 { 81 APInt APTwo(32, 2, false); 82 auto *IslTwo = isl_valFromAPInt(IslCtx, APTwo, false); 83 EXPECT_EQ(0, isl_val_cmp_si(IslTwo, 2)); 84 isl_val_free(IslTwo); 85 } 86 87 { 88 APInt APNOne(32, (1ull << 32) - 1, false); 89 auto *IslNOne = isl_valFromAPInt(IslCtx, APNOne, false); 90 auto *IslRef = isl_val_int_from_ui(IslCtx, (1ull << 32) - 1); 91 EXPECT_EQ(isl_bool_true, isl_val_eq(IslNOne, IslRef)); 92 isl_val_free(IslNOne); 93 isl_val_free(IslRef); 94 } 95 96 { 97 APInt APLarge(130, 2, false); 98 APLarge = APLarge.shl(70); 99 auto *IslLarge = isl_valFromAPInt(IslCtx, APLarge, false); 100 auto *IslRef = isl_val_int_from_ui(IslCtx, 71); 101 IslRef = isl_val_2exp(IslRef); 102 EXPECT_EQ(isl_bool_true, isl_val_eq(IslLarge, IslRef)); 103 isl_val_free(IslLarge); 104 isl_val_free(IslRef); 105 } 106 107 isl_ctx_free(IslCtx); 108 } 109 110 TEST(Isl, IslValToAPInt) { 111 isl_ctx *IslCtx = isl_ctx_alloc(); 112 113 { 114 auto *IslNOne = isl_val_int_from_si(IslCtx, -1); 115 auto APNOne = APIntFromVal(IslNOne); 116 // Compare with the two's complement of -1 in a 1-bit integer. 117 EXPECT_EQ(1, APNOne); 118 EXPECT_EQ(1u, APNOne.getBitWidth()); 119 } 120 121 { 122 auto *IslNTwo = isl_val_int_from_si(IslCtx, -2); 123 auto APNTwo = APIntFromVal(IslNTwo); 124 // Compare with the two's complement of -2 in a 2-bit integer. 125 EXPECT_EQ(2, APNTwo); 126 EXPECT_EQ(2u, APNTwo.getBitWidth()); 127 } 128 129 { 130 auto *IslNThree = isl_val_int_from_si(IslCtx, -3); 131 auto APNThree = APIntFromVal(IslNThree); 132 // Compare with the two's complement of -3 in a 3-bit integer. 133 EXPECT_EQ(5, APNThree); 134 EXPECT_EQ(3u, APNThree.getBitWidth()); 135 } 136 137 { 138 auto *IslNFour = isl_val_int_from_si(IslCtx, -4); 139 auto APNFour = APIntFromVal(IslNFour); 140 // Compare with the two's complement of -4 in a 3-bit integer. 141 EXPECT_EQ(4, APNFour); 142 EXPECT_EQ(3u, APNFour.getBitWidth()); 143 } 144 145 { 146 auto *IslZero = isl_val_int_from_ui(IslCtx, 0); 147 auto APZero = APIntFromVal(IslZero); 148 EXPECT_EQ(0, APZero); 149 EXPECT_EQ(1u, APZero.getBitWidth()); 150 } 151 152 { 153 auto *IslOne = isl_val_int_from_ui(IslCtx, 1); 154 auto APOne = APIntFromVal(IslOne); 155 EXPECT_EQ(1, APOne); 156 EXPECT_EQ(2u, APOne.getBitWidth()); 157 } 158 159 { 160 auto *IslTwo = isl_val_int_from_ui(IslCtx, 2); 161 auto APTwo = APIntFromVal(IslTwo); 162 EXPECT_EQ(2, APTwo); 163 EXPECT_EQ(3u, APTwo.getBitWidth()); 164 } 165 166 { 167 auto *IslThree = isl_val_int_from_ui(IslCtx, 3); 168 auto APThree = APIntFromVal(IslThree); 169 EXPECT_EQ(3, APThree); 170 EXPECT_EQ(3u, APThree.getBitWidth()); 171 } 172 173 { 174 auto *IslFour = isl_val_int_from_ui(IslCtx, 4); 175 auto APFour = APIntFromVal(IslFour); 176 EXPECT_EQ(4, APFour); 177 EXPECT_EQ(4u, APFour.getBitWidth()); 178 } 179 180 { 181 auto *IslNOne = isl_val_int_from_ui(IslCtx, (1ull << 32) - 1); 182 auto APNOne = APIntFromVal(IslNOne); 183 EXPECT_EQ((1ull << 32) - 1, APNOne); 184 EXPECT_EQ(33u, APNOne.getBitWidth()); 185 } 186 187 { 188 auto *IslLargeNum = isl_val_int_from_ui(IslCtx, 60); 189 IslLargeNum = isl_val_2exp(IslLargeNum); 190 IslLargeNum = isl_val_sub_ui(IslLargeNum, 1); 191 auto APLargeNum = APIntFromVal(IslLargeNum); 192 EXPECT_EQ((1ull << 60) - 1, APLargeNum); 193 EXPECT_EQ(61u, APLargeNum.getBitWidth()); 194 } 195 196 { 197 auto *IslExp = isl_val_int_from_ui(IslCtx, 500); 198 auto *IslLargePow2 = isl_val_2exp(IslExp); 199 auto APLargePow2 = APIntFromVal(IslLargePow2); 200 EXPECT_TRUE(APLargePow2.isPowerOf2()); 201 EXPECT_EQ(502u, APLargePow2.getBitWidth()); 202 EXPECT_EQ(502u, APLargePow2.getMinSignedBits()); 203 } 204 205 { 206 auto *IslExp = isl_val_int_from_ui(IslCtx, 500); 207 auto *IslLargeNPow2 = isl_val_neg(isl_val_2exp(IslExp)); 208 auto APLargeNPow2 = APIntFromVal(IslLargeNPow2); 209 EXPECT_EQ(501u, APLargeNPow2.getBitWidth()); 210 EXPECT_EQ(501u, APLargeNPow2.getMinSignedBits()); 211 EXPECT_EQ(500, (-APLargeNPow2).exactLogBase2()); 212 } 213 214 { 215 auto *IslExp = isl_val_int_from_ui(IslCtx, 512); 216 auto *IslLargePow2 = isl_val_2exp(IslExp); 217 auto APLargePow2 = APIntFromVal(IslLargePow2); 218 EXPECT_TRUE(APLargePow2.isPowerOf2()); 219 EXPECT_EQ(514u, APLargePow2.getBitWidth()); 220 EXPECT_EQ(514u, APLargePow2.getMinSignedBits()); 221 } 222 223 { 224 auto *IslExp = isl_val_int_from_ui(IslCtx, 512); 225 auto *IslLargeNPow2 = isl_val_neg(isl_val_2exp(IslExp)); 226 auto APLargeNPow2 = APIntFromVal(IslLargeNPow2); 227 EXPECT_EQ(513u, APLargeNPow2.getBitWidth()); 228 EXPECT_EQ(513u, APLargeNPow2.getMinSignedBits()); 229 EXPECT_EQ(512, (-APLargeNPow2).exactLogBase2()); 230 } 231 232 isl_ctx_free(IslCtx); 233 } 234 235 TEST(Isl, Foreach) { 236 std::unique_ptr<isl_ctx, decltype(&isl_ctx_free)> Ctx(isl_ctx_alloc(), 237 &isl_ctx_free); 238 239 auto MapSpace = give(isl_space_alloc(Ctx.get(), 0, 1, 1)); 240 auto TestBMap = give(isl_basic_map_universe(MapSpace.copy())); 241 TestBMap = give(isl_basic_map_fix_si(TestBMap.take(), isl_dim_in, 0, 0)); 242 TestBMap = give(isl_basic_map_fix_si(TestBMap.take(), isl_dim_out, 0, 0)); 243 auto TestMap = give(isl_map_from_basic_map(TestBMap.copy())); 244 auto TestUMap = give(isl_union_map_from_map(TestMap.copy())); 245 246 auto SetSpace = give(isl_space_set_alloc(Ctx.get(), 0, 1)); 247 auto TestBSet = 248 give(isl_basic_set_from_point(isl_point_zero(SetSpace.copy()))); 249 auto TestSet = give(isl_set_from_basic_set(TestBSet.copy())); 250 auto TestUSet = give(isl_union_set_from_set(TestSet.copy())); 251 252 { 253 auto NumBMaps = 0; 254 foreachElt(TestMap, [&](IslPtr<isl_basic_map> BMap) { 255 EXPECT_EQ(isl_bool_true, 256 isl_basic_map_is_equal(BMap.keep(), TestBMap.keep())); 257 NumBMaps++; 258 }); 259 EXPECT_EQ(1, NumBMaps); 260 } 261 262 { 263 auto NumBSets = 0; 264 foreachElt(TestSet, [&](IslPtr<isl_basic_set> BSet) { 265 EXPECT_EQ(isl_bool_true, 266 isl_basic_set_is_equal(BSet.keep(), TestBSet.keep())); 267 NumBSets++; 268 }); 269 EXPECT_EQ(1, NumBSets); 270 } 271 272 { 273 auto NumMaps = 0; 274 foreachElt(TestUMap, [&](IslPtr<isl_map> Map) { 275 EXPECT_EQ(isl_bool_true, isl_map_is_equal(Map.keep(), TestMap.keep())); 276 NumMaps++; 277 }); 278 EXPECT_EQ(1, NumMaps); 279 } 280 281 { 282 auto NumSets = 0; 283 foreachElt(TestUSet, [&](IslPtr<isl_set> Set) { 284 EXPECT_EQ(isl_bool_true, isl_set_is_equal(Set.keep(), TestSet.keep())); 285 NumSets++; 286 }); 287 EXPECT_EQ(1, NumSets); 288 } 289 290 { 291 auto UPwAff = give(isl_union_pw_aff_val_on_domain(TestUSet.copy(), 292 isl_val_zero(Ctx.get()))); 293 auto NumPwAffs = 0; 294 foreachElt(UPwAff, [&](IslPtr<isl_pw_aff> PwAff) { 295 EXPECT_EQ(isl_bool_true, isl_pw_aff_is_cst(PwAff.keep())); 296 NumPwAffs++; 297 }); 298 EXPECT_EQ(1, NumPwAffs); 299 } 300 301 { 302 auto NumBMaps = 0; 303 EXPECT_EQ(isl_stat_error, 304 foreachEltWithBreak( 305 TestMap, [&](IslPtr<isl_basic_map> BMap) -> isl_stat { 306 EXPECT_EQ(isl_bool_true, isl_basic_map_is_equal( 307 BMap.keep(), TestBMap.keep())); 308 NumBMaps++; 309 return isl_stat_error; 310 })); 311 EXPECT_EQ(1, NumBMaps); 312 } 313 314 { 315 auto NumMaps = 0; 316 EXPECT_EQ( 317 isl_stat_error, 318 foreachEltWithBreak(TestUMap, [&](IslPtr<isl_map> Map) -> isl_stat { 319 EXPECT_EQ(isl_bool_true, 320 isl_map_is_equal(Map.keep(), TestMap.keep())); 321 NumMaps++; 322 return isl_stat_error; 323 })); 324 EXPECT_EQ(1, NumMaps); 325 } 326 327 { 328 auto TestPwAff = 329 give(isl_pw_aff_val_on_domain(TestSet.copy(), isl_val_zero(Ctx.get()))); 330 auto NumPieces = 0; 331 foreachPieceWithBreak(TestPwAff, [&](IslPtr<isl_set> Domain, 332 IslPtr<isl_aff> Aff) -> isl_stat { 333 EXPECT_EQ(isl_bool_true, isl_set_is_equal(Domain.keep(), TestSet.keep())); 334 EXPECT_EQ(isl_bool_true, isl_aff_is_cst(Aff.keep())); 335 NumPieces++; 336 return isl_stat_error; 337 }); 338 EXPECT_EQ(1, NumPieces); 339 } 340 } 341 342 } // anonymous namespace 343