unittests/AsmParser/AsmParserTest.cpp

   1 //===- llvm/unittest/AsmParser/AsmParserTest.cpp - asm parser unittests ---===//
   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 "llvm/ADT/StringRef.h"
  11 #include "llvm/AsmParser/Parser.h"
  12 #include "llvm/AsmParser/SlotMapping.h"
  13 #include "llvm/IR/Constants.h"
  14 #include "llvm/IR/LLVMContext.h"
  15 #include "llvm/IR/Module.h"
  16 #include "llvm/Support/SourceMgr.h"
  17 #include "gtest/gtest.h"
  18
  19 using namespace llvm;
  20
  21 namespace {
  22
  23 TEST(AsmParserTest, NullTerminatedInput) {
  24   LLVMContext Ctx;
  25   StringRef Source = "; Empty module \n";
  26   SMDiagnostic Error;
  27   auto Mod = parseAssemblyString(Source, Error, Ctx);
  28
  29   EXPECT_TRUE(Mod != nullptr);
  30   EXPECT_TRUE(Error.getMessage().empty());
  31 }
  32
  33 #ifdef GTEST_HAS_DEATH_TEST
  34 #ifndef NDEBUG
  35
  36 TEST(AsmParserTest, NonNullTerminatedInput) {
  37   LLVMContext Ctx;
  38   StringRef Source = "; Empty module \n\1\2";
  39   SMDiagnostic Error;
  40   std::unique_ptr<Module> Mod;
  41   EXPECT_DEATH(Mod = parseAssemblyString(Source.substr(0, Source.size() - 2),
  42                                          Error, Ctx),
  43                "Buffer is not null terminated!");
  44 }
  45
  46 #endif
  47 #endif
  48
  49 TEST(AsmParserTest, SlotMappingTest) {
  50   LLVMContext Ctx;
  51   StringRef Source = "@0 = global i32 0\n !0 = !{}\n !42 = !{i32 42}";
  52   SMDiagnostic Error;
  53   SlotMapping Mapping;
  54   auto Mod = parseAssemblyString(Source, Error, Ctx, &Mapping);
  55
  56   EXPECT_TRUE(Mod != nullptr);
  57   EXPECT_TRUE(Error.getMessage().empty());
  58
  59   ASSERT_EQ(Mapping.GlobalValues.size(), 1u);
  60   EXPECT_TRUE(isa<GlobalVariable>(Mapping.GlobalValues[0]));
  61
  62   EXPECT_EQ(Mapping.MetadataNodes.size(), 2u);
  63   EXPECT_EQ(Mapping.MetadataNodes.count(0), 1u);
  64   EXPECT_EQ(Mapping.MetadataNodes.count(42), 1u);
  65   EXPECT_EQ(Mapping.MetadataNodes.count(1), 0u);
  66 }
  67
  68 TEST(AsmParserTest, TypeAndConstantValueParsing) {
  69   LLVMContext Ctx;
  70   SMDiagnostic Error;
  71   StringRef Source = "define void @test() {\n  entry:\n  ret void\n}";
  72   auto Mod = parseAssemblyString(Source, Error, Ctx);
  73   ASSERT_TRUE(Mod != nullptr);
  74   auto &M = *Mod;
  75
  76   const Value *V;
  77   V = parseConstantValue("double 3.5", Error, M);
  78   ASSERT_TRUE(V);
  79   EXPECT_TRUE(V->getType()->isDoubleTy());
  80   ASSERT_TRUE(isa<ConstantFP>(V));
  81   EXPECT_TRUE(cast<ConstantFP>(V)->isExactlyValue(3.5));
  82
  83   V = parseConstantValue("i32 42", Error, M);
  84   ASSERT_TRUE(V);
  85   EXPECT_TRUE(V->getType()->isIntegerTy());
  86   ASSERT_TRUE(isa<ConstantInt>(V));
  87   EXPECT_TRUE(cast<ConstantInt>(V)->equalsInt(42));
  88
  89   V = parseConstantValue("<4 x i32> <i32 0, i32 1, i32 2, i32 3>", Error, M);
  90   ASSERT_TRUE(V);
  91   EXPECT_TRUE(V->getType()->isVectorTy());
  92   ASSERT_TRUE(isa<ConstantDataVector>(V));
  93
  94   V = parseConstantValue("i32 add (i32 1, i32 2)", Error, M);
  95   ASSERT_TRUE(V);
  96   ASSERT_TRUE(isa<ConstantInt>(V));
  97
  98   V = parseConstantValue("i8* blockaddress(@test, %entry)", Error, M);
  99   ASSERT_TRUE(V);
 100   ASSERT_TRUE(isa<BlockAddress>(V));
 101
 102   V = parseConstantValue("i8** undef", Error, M);
 103   ASSERT_TRUE(V);
 104   ASSERT_TRUE(isa<UndefValue>(V));
 105
 106   EXPECT_FALSE(parseConstantValue("duble 3.25", Error, M));
 107   EXPECT_EQ(Error.getMessage(), "expected type");
 108
 109   EXPECT_FALSE(parseConstantValue("i32 3.25", Error, M));
 110   EXPECT_EQ(Error.getMessage(), "floating point constant invalid for type");
 111
 112   EXPECT_FALSE(parseConstantValue("i32* @foo", Error, M));
 113   EXPECT_EQ(Error.getMessage(), "expected a constant value");
 114
 115   EXPECT_FALSE(parseConstantValue("i32 3, ", Error, M));
 116   EXPECT_EQ(Error.getMessage(), "expected end of string");
 117 }
 118
 119 TEST(AsmParserTest, TypeAndConstantValueWithSlotMappingParsing) {
 120   LLVMContext Ctx;
 121   SMDiagnostic Error;
 122   StringRef Source =
 123       "%st = type { i32, i32 }\n"
 124       "@v = common global [50 x %st] zeroinitializer, align 16\n"
 125       "%0 = type { i32, i32, i32, i32 }\n"
 126       "@g = common global [50 x %0] zeroinitializer, align 16\n"
 127       "define void @marker4(i64 %d) {\n"
 128       "entry:\n"
 129       "  %conv = trunc i64 %d to i32\n"
 130       "  store i32 %conv, i32* getelementptr inbounds "
 131       "    ([50 x %st], [50 x %st]* @v, i64 0, i64 0, i32 0), align 16\n"
 132       "  store i32 %conv, i32* getelementptr inbounds "
 133       "    ([50 x %0], [50 x %0]* @g, i64 0, i64 0, i32 0), align 16\n"
 134       "  ret void\n"
 135       "}";
 136   SlotMapping Mapping;
 137   auto Mod = parseAssemblyString(Source, Error, Ctx, &Mapping);
 138   ASSERT_TRUE(Mod != nullptr);
 139   auto &M = *Mod;
 140
 141   const Value *V;
 142   V = parseConstantValue("i32* getelementptr inbounds ([50 x %st], [50 x %st]* "
 143                          "@v, i64 0, i64 0, i32 0)",
 144                          Error, M, &Mapping);
 145   ASSERT_TRUE(V);
 146   ASSERT_TRUE(isa<ConstantExpr>(V));
 147
 148   V = parseConstantValue("i32* getelementptr inbounds ([50 x %0], [50 x %0]* "
 149                          "@g, i64 0, i64 0, i32 0)",
 150                          Error, M, &Mapping);
 151   ASSERT_TRUE(V);
 152   ASSERT_TRUE(isa<ConstantExpr>(V));
 153 }
 154
 155 TEST(AsmParserTest, TypeWithSlotMappingParsing) {
 156   LLVMContext Ctx;
 157   SMDiagnostic Error;
 158   StringRef Source =
 159       "%st = type { i32, i32 }\n"
 160       "@v = common global [50 x %st] zeroinitializer, align 16\n"
 161       "%0 = type { i32, i32, i32, i32 }\n"
 162       "@g = common global [50 x %0] zeroinitializer, align 16\n"
 163       "define void @marker4(i64 %d) {\n"
 164       "entry:\n"
 165       "  %conv = trunc i64 %d to i32\n"
 166       "  store i32 %conv, i32* getelementptr inbounds "
 167       "    ([50 x %st], [50 x %st]* @v, i64 0, i64 0, i32 0), align 16\n"
 168       "  store i32 %conv, i32* getelementptr inbounds "
 169       "    ([50 x %0], [50 x %0]* @g, i64 0, i64 0, i32 0), align 16\n"
 170       "  ret void\n"
 171       "}";
 172   SlotMapping Mapping;
 173   auto Mod = parseAssemblyString(Source, Error, Ctx, &Mapping);
 174   ASSERT_TRUE(Mod != nullptr);
 175   auto &M = *Mod;
 176
 177   // Check we properly parse integer types.
 178   Type *Ty;
 179   Ty = parseType("i32", Error, M, &Mapping);
 180   ASSERT_TRUE(Ty);
 181   ASSERT_TRUE(Ty->isIntegerTy());
 182   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
 183
 184   // Check we properly parse integer types with exotic size.
 185   Ty = parseType("i13", Error, M, &Mapping);
 186   ASSERT_TRUE(Ty);
 187   ASSERT_TRUE(Ty->isIntegerTy());
 188   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 13);
 189
 190   // Check we properly parse floating point types.
 191   Ty = parseType("float", Error, M, &Mapping);
 192   ASSERT_TRUE(Ty);
 193   ASSERT_TRUE(Ty->isFloatTy());
 194
 195   Ty = parseType("double", Error, M, &Mapping);
 196   ASSERT_TRUE(Ty);
 197   ASSERT_TRUE(Ty->isDoubleTy());
 198
 199   // Check we properly parse struct types.
 200   // Named struct.
 201   Ty = parseType("%st", Error, M, &Mapping);
 202   ASSERT_TRUE(Ty);
 203   ASSERT_TRUE(Ty->isStructTy());
 204
 205   // Check the details of the struct.
 206   StructType *ST = cast<StructType>(Ty);
 207   ASSERT_TRUE(ST->getNumElements() == 2);
 208   for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i) {
 209     Ty = ST->getElementType(i);
 210     ASSERT_TRUE(Ty->isIntegerTy());
 211     ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
 212   }
 213
 214   // Anonymous struct.
 215   Ty = parseType("%0", Error, M, &Mapping);
 216   ASSERT_TRUE(Ty);
 217   ASSERT_TRUE(Ty->isStructTy());
 218
 219   // Check the details of the struct.
 220   ST = cast<StructType>(Ty);
 221   ASSERT_TRUE(ST->getNumElements() == 4);
 222   for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i) {
 223     Ty = ST->getElementType(i);
 224     ASSERT_TRUE(Ty->isIntegerTy());
 225     ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
 226   }
 227
 228   // Check we properly parse vector types.
 229   Ty = parseType("<5 x i32>", Error, M, &Mapping);
 230   ASSERT_TRUE(Ty);
 231   ASSERT_TRUE(Ty->isVectorTy());
 232
 233   // Check the details of the vector.
 234   VectorType *VT = cast<VectorType>(Ty);
 235   ASSERT_TRUE(VT->getNumElements() == 5);
 236   ASSERT_TRUE(VT->getBitWidth() == 160);
 237   Ty = VT->getElementType();
 238   ASSERT_TRUE(Ty->isIntegerTy());
 239   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
 240
 241   // Opaque struct.
 242   Ty = parseType("%opaque", Error, M, &Mapping);
 243   ASSERT_TRUE(Ty);
 244   ASSERT_TRUE(Ty->isStructTy());
 245
 246   ST = cast<StructType>(Ty);
 247   ASSERT_TRUE(ST->isOpaque());
 248
 249   // Check we properly parse pointer types.
 250   // One indirection.
 251   Ty = parseType("i32*", Error, M, &Mapping);
 252   ASSERT_TRUE(Ty);
 253   ASSERT_TRUE(Ty->isPointerTy());
 254
 255   PointerType *PT = cast<PointerType>(Ty);
 256   Ty = PT->getElementType();
 257   ASSERT_TRUE(Ty->isIntegerTy());
 258   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
 259
 260   // Two indirections.
 261   Ty = parseType("i32**", Error, M, &Mapping);
 262   ASSERT_TRUE(Ty);
 263   ASSERT_TRUE(Ty->isPointerTy());
 264
 265   PT = cast<PointerType>(Ty);
 266   Ty = PT->getElementType();
 267   ASSERT_TRUE(Ty->isPointerTy());
 268
 269   PT = cast<PointerType>(Ty);
 270   Ty = PT->getElementType();
 271   ASSERT_TRUE(Ty->isIntegerTy());
 272   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
 273
 274   // Check that we reject types with garbage.
 275   Ty = parseType("i32 garbage", Error, M, &Mapping);
 276   ASSERT_TRUE(!Ty);
 277 }
 278
 279 TEST(AsmParserTest, TypeAtBeginningWithSlotMappingParsing) {
 280   LLVMContext Ctx;
 281   SMDiagnostic Error;
 282   StringRef Source =
 283       "%st = type { i32, i32 }\n"
 284       "@v = common global [50 x %st] zeroinitializer, align 16\n"
 285       "%0 = type { i32, i32, i32, i32 }\n"
 286       "@g = common global [50 x %0] zeroinitializer, align 16\n"
 287       "define void @marker4(i64 %d) {\n"
 288       "entry:\n"
 289       "  %conv = trunc i64 %d to i32\n"
 290       "  store i32 %conv, i32* getelementptr inbounds "
 291       "    ([50 x %st], [50 x %st]* @v, i64 0, i64 0, i32 0), align 16\n"
 292       "  store i32 %conv, i32* getelementptr inbounds "
 293       "    ([50 x %0], [50 x %0]* @g, i64 0, i64 0, i32 0), align 16\n"
 294       "  ret void\n"
 295       "}";
 296   SlotMapping Mapping;
 297   auto Mod = parseAssemblyString(Source, Error, Ctx, &Mapping);
 298   ASSERT_TRUE(Mod != nullptr);
 299   auto &M = *Mod;
 300   unsigned Read;
 301
 302   // Check we properly parse integer types.
 303   Type *Ty;
 304   Ty = parseTypeAtBeginning("i32", Read, Error, M, &Mapping);
 305   ASSERT_TRUE(Ty);
 306   ASSERT_TRUE(Ty->isIntegerTy());
 307   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
 308   ASSERT_TRUE(Read == 3);
 309
 310   // Check we properly parse integer types with exotic size.
 311   Ty = parseTypeAtBeginning("i13", Read, Error, M, &Mapping);
 312   ASSERT_TRUE(Ty);
 313   ASSERT_TRUE(Ty->isIntegerTy());
 314   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 13);
 315   ASSERT_TRUE(Read == 3);
 316
 317   // Check we properly parse floating point types.
 318   Ty = parseTypeAtBeginning("float", Read, Error, M, &Mapping);
 319   ASSERT_TRUE(Ty);
 320   ASSERT_TRUE(Ty->isFloatTy());
 321   ASSERT_TRUE(Read == 5);
 322
 323   Ty = parseTypeAtBeginning("double", Read, Error, M, &Mapping);
 324   ASSERT_TRUE(Ty);
 325   ASSERT_TRUE(Ty->isDoubleTy());
 326   ASSERT_TRUE(Read == 6);
 327
 328   // Check we properly parse struct types.
 329   // Named struct.
 330   Ty = parseTypeAtBeginning("%st", Read, Error, M, &Mapping);
 331   ASSERT_TRUE(Ty);
 332   ASSERT_TRUE(Ty->isStructTy());
 333   ASSERT_TRUE(Read == 3);
 334
 335   // Check the details of the struct.
 336   StructType *ST = cast<StructType>(Ty);
 337   ASSERT_TRUE(ST->getNumElements() == 2);
 338   for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i) {
 339     Ty = ST->getElementType(i);
 340     ASSERT_TRUE(Ty->isIntegerTy());
 341     ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
 342   }
 343
 344   // Anonymous struct.
 345   Ty = parseTypeAtBeginning("%0", Read, Error, M, &Mapping);
 346   ASSERT_TRUE(Ty);
 347   ASSERT_TRUE(Ty->isStructTy());
 348   ASSERT_TRUE(Read == 2);
 349
 350   // Check the details of the struct.
 351   ST = cast<StructType>(Ty);
 352   ASSERT_TRUE(ST->getNumElements() == 4);
 353   for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i) {
 354     Ty = ST->getElementType(i);
 355     ASSERT_TRUE(Ty->isIntegerTy());
 356     ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
 357   }
 358
 359   // Check we properly parse vector types.
 360   Ty = parseTypeAtBeginning("<5 x i32>", Read, Error, M, &Mapping);
 361   ASSERT_TRUE(Ty);
 362   ASSERT_TRUE(Ty->isVectorTy());
 363   ASSERT_TRUE(Read == 9);
 364
 365   // Check the details of the vector.
 366   VectorType *VT = cast<VectorType>(Ty);
 367   ASSERT_TRUE(VT->getNumElements() == 5);
 368   ASSERT_TRUE(VT->getBitWidth() == 160);
 369   Ty = VT->getElementType();
 370   ASSERT_TRUE(Ty->isIntegerTy());
 371   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
 372
 373   // Opaque struct.
 374   Ty = parseTypeAtBeginning("%opaque", Read, Error, M, &Mapping);
 375   ASSERT_TRUE(Ty);
 376   ASSERT_TRUE(Ty->isStructTy());
 377   ASSERT_TRUE(Read == 7);
 378
 379   ST = cast<StructType>(Ty);
 380   ASSERT_TRUE(ST->isOpaque());
 381
 382   // Check we properly parse pointer types.
 383   // One indirection.
 384   Ty = parseTypeAtBeginning("i32*", Read, Error, M, &Mapping);
 385   ASSERT_TRUE(Ty);
 386   ASSERT_TRUE(Ty->isPointerTy());
 387   ASSERT_TRUE(Read == 4);
 388
 389   PointerType *PT = cast<PointerType>(Ty);
 390   Ty = PT->getElementType();
 391   ASSERT_TRUE(Ty->isIntegerTy());
 392   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
 393
 394   // Two indirections.
 395   Ty = parseTypeAtBeginning("i32**", Read, Error, M, &Mapping);
 396   ASSERT_TRUE(Ty);
 397   ASSERT_TRUE(Ty->isPointerTy());
 398   ASSERT_TRUE(Read == 5);
 399
 400   PT = cast<PointerType>(Ty);
 401   Ty = PT->getElementType();
 402   ASSERT_TRUE(Ty->isPointerTy());
 403
 404   PT = cast<PointerType>(Ty);
 405   Ty = PT->getElementType();
 406   ASSERT_TRUE(Ty->isIntegerTy());
 407   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
 408
 409   // Check that we reject types with garbage.
 410   Ty = parseTypeAtBeginning("i32 garbage", Read, Error, M, &Mapping);
 411   ASSERT_TRUE(Ty);
 412   ASSERT_TRUE(Ty->isIntegerTy());
 413   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
 414   // We go to the next token, i.e., we read "i32" + ' '.
 415   ASSERT_TRUE(Read == 4);
 416 }
 417
 418 } // end anonymous namespace