unittests/IR/IRBuilderTest.cpp

   1 //===- llvm/unittest/IR/IRBuilderTest.cpp - IRBuilder tests ---------------===//
   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 #include "llvm/IR/IRBuilder.h"
  10 #include "llvm/IR/BasicBlock.h"
  11 #include "llvm/IR/DIBuilder.h"
  12 #include "llvm/IR/DataLayout.h"
  13 #include "llvm/IR/Function.h"
  14 #include "llvm/IR/IntrinsicInst.h"
  15 #include "llvm/IR/LLVMContext.h"
  16 #include "llvm/IR/MDBuilder.h"
  17 #include "llvm/IR/Module.h"
  18 #include "llvm/IR/NoFolder.h"
  19 #include "llvm/IR/Verifier.h"
  20 #include "gtest/gtest.h"
  21
  22 using namespace llvm;
  23
  24 namespace {
  25
  26 class IRBuilderTest : public testing::Test {
  27 protected:
  28   void SetUp() override {
  29     M.reset(new Module("MyModule", Ctx));
  30     FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
  31                                           /*isVarArg=*/false);
  32     F = Function::Create(FTy, Function::ExternalLinkage, "", M.get());
  33     BB = BasicBlock::Create(Ctx, "", F);
  34     GV = new GlobalVariable(*M, Type::getFloatTy(Ctx), true,
  35                             GlobalValue::ExternalLinkage, nullptr);
  36   }
  37
  38   void TearDown() override {
  39     BB = nullptr;
  40     M.reset();
  41   }
  42
  43   LLVMContext Ctx;
  44   std::unique_ptr<Module> M;
  45   Function *F;
  46   BasicBlock *BB;
  47   GlobalVariable *GV;
  48 };
  49
  50 TEST_F(IRBuilderTest, Intrinsics) {
  51   IRBuilder<> Builder(BB);
  52   Value *V;
  53   Instruction *I;
  54   CallInst *Call;
  55   IntrinsicInst *II;
  56
  57   V = Builder.CreateLoad(GV->getValueType(), GV);
  58   I = cast<Instruction>(Builder.CreateFAdd(V, V));
  59   I->setHasNoInfs(true);
  60   I->setHasNoNaNs(false);
  61
  62   Call = Builder.CreateMinNum(V, V);
  63   II = cast<IntrinsicInst>(Call);
  64   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::minnum);
  65
  66   Call = Builder.CreateMaxNum(V, V);
  67   II = cast<IntrinsicInst>(Call);
  68   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::maxnum);
  69
  70   Call = Builder.CreateMinimum(V, V);
  71   II = cast<IntrinsicInst>(Call);
  72   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::minimum);
  73
  74   Call = Builder.CreateMaximum(V, V);
  75   II = cast<IntrinsicInst>(Call);
  76   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::maximum);
  77
  78   Call = Builder.CreateIntrinsic(Intrinsic::readcyclecounter, {}, {});
  79   II = cast<IntrinsicInst>(Call);
  80   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::readcyclecounter);
  81
  82   Call = Builder.CreateUnaryIntrinsic(Intrinsic::fabs, V);
  83   II = cast<IntrinsicInst>(Call);
  84   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::fabs);
  85   EXPECT_FALSE(II->hasNoInfs());
  86   EXPECT_FALSE(II->hasNoNaNs());
  87
  88   Call = Builder.CreateUnaryIntrinsic(Intrinsic::fabs, V, I);
  89   II = cast<IntrinsicInst>(Call);
  90   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::fabs);
  91   EXPECT_TRUE(II->hasNoInfs());
  92   EXPECT_FALSE(II->hasNoNaNs());
  93
  94   Call = Builder.CreateBinaryIntrinsic(Intrinsic::pow, V, V);
  95   II = cast<IntrinsicInst>(Call);
  96   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::pow);
  97   EXPECT_FALSE(II->hasNoInfs());
  98   EXPECT_FALSE(II->hasNoNaNs());
  99
 100   Call = Builder.CreateBinaryIntrinsic(Intrinsic::pow, V, V, I);
 101   II = cast<IntrinsicInst>(Call);
 102   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::pow);
 103   EXPECT_TRUE(II->hasNoInfs());
 104   EXPECT_FALSE(II->hasNoNaNs());
 105
 106   Call = Builder.CreateIntrinsic(Intrinsic::fma, {V->getType()}, {V, V, V});
 107   II = cast<IntrinsicInst>(Call);
 108   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::fma);
 109   EXPECT_FALSE(II->hasNoInfs());
 110   EXPECT_FALSE(II->hasNoNaNs());
 111
 112   Call = Builder.CreateIntrinsic(Intrinsic::fma, {V->getType()}, {V, V, V}, I);
 113   II = cast<IntrinsicInst>(Call);
 114   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::fma);
 115   EXPECT_TRUE(II->hasNoInfs());
 116   EXPECT_FALSE(II->hasNoNaNs());
 117
 118   Call = Builder.CreateIntrinsic(Intrinsic::fma, {V->getType()}, {V, V, V}, I);
 119   II = cast<IntrinsicInst>(Call);
 120   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::fma);
 121   EXPECT_TRUE(II->hasNoInfs());
 122   EXPECT_FALSE(II->hasNoNaNs());
 123 }
 124
 125 TEST_F(IRBuilderTest, IntrinsicsWithScalableVectors) {
 126   IRBuilder<> Builder(BB);
 127   CallInst *Call;
 128   FunctionType *FTy;
 129
 130   // Test scalable flag isn't dropped for intrinsic that is explicitly defined
 131   // with scalable vectors, e.g. LLVMType<nxv4i32>.
 132   Type *SrcVecTy = VectorType::get(Builder.getHalfTy(), 8, true);
 133   Type *DstVecTy = VectorType::get(Builder.getInt32Ty(), 4, true);
 134   Type *PredTy = VectorType::get(Builder.getInt1Ty(), 16, true);
 135
 136   SmallVector<Value*, 3> ArgTys;
 137   ArgTys.push_back(UndefValue::get(DstVecTy));
 138   ArgTys.push_back(UndefValue::get(PredTy));
 139   ArgTys.push_back(UndefValue::get(SrcVecTy));
 140
 141   Call = Builder.CreateIntrinsic(Intrinsic::aarch64_sve_fcvtzs_i32f16, {},
 142                                  ArgTys, nullptr, "aarch64.sve.fcvtzs.i32f16");
 143   FTy = Call->getFunctionType();
 144   EXPECT_EQ(FTy->getReturnType(), DstVecTy);
 145   for (unsigned i = 0; i != ArgTys.size(); ++i)
 146     EXPECT_EQ(FTy->getParamType(i), ArgTys[i]->getType());
 147
 148   // Test scalable flag isn't dropped for intrinsic defined with
 149   // LLVMScalarOrSameVectorWidth.
 150
 151   Type *VecTy = VectorType::get(Builder.getInt32Ty(), 4, true);
 152   Type *PtrToVecTy = VecTy->getPointerTo();
 153   PredTy = VectorType::get(Builder.getInt1Ty(), 4, true);
 154
 155   ArgTys.clear();
 156   ArgTys.push_back(UndefValue::get(PtrToVecTy));
 157   ArgTys.push_back(UndefValue::get(Builder.getInt32Ty()));
 158   ArgTys.push_back(UndefValue::get(PredTy));
 159   ArgTys.push_back(UndefValue::get(VecTy));
 160
 161   Call = Builder.CreateIntrinsic(Intrinsic::masked_load,
 162                                  {VecTy, PtrToVecTy}, ArgTys,
 163                                  nullptr, "masked.load");
 164   FTy = Call->getFunctionType();
 165   EXPECT_EQ(FTy->getReturnType(), VecTy);
 166   for (unsigned i = 0; i != ArgTys.size(); ++i)
 167     EXPECT_EQ(FTy->getParamType(i), ArgTys[i]->getType());
 168 }
 169
 170 TEST_F(IRBuilderTest, ConstrainedFP) {
 171   IRBuilder<> Builder(BB);
 172   Value *V;
 173   Value *VDouble;
 174   CallInst *Call;
 175   IntrinsicInst *II;
 176   GlobalVariable *GVDouble = new GlobalVariable(*M, Type::getDoubleTy(Ctx),
 177                             true, GlobalValue::ExternalLinkage, nullptr);
 178
 179   V = Builder.CreateLoad(GV->getValueType(), GV);
 180   VDouble = Builder.CreateLoad(GVDouble->getValueType(), GVDouble);
 181
 182   // See if we get constrained intrinsics instead of non-constrained
 183   // instructions.
 184   Builder.setIsFPConstrained(true);
 185
 186   V = Builder.CreateFAdd(V, V);
 187   ASSERT_TRUE(isa<IntrinsicInst>(V));
 188   II = cast<IntrinsicInst>(V);
 189   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fadd);
 190
 191   V = Builder.CreateFSub(V, V);
 192   ASSERT_TRUE(isa<IntrinsicInst>(V));
 193   II = cast<IntrinsicInst>(V);
 194   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fsub);
 195
 196   V = Builder.CreateFMul(V, V);
 197   ASSERT_TRUE(isa<IntrinsicInst>(V));
 198   II = cast<IntrinsicInst>(V);
 199   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fmul);
 200
 201   V = Builder.CreateFDiv(V, V);
 202   ASSERT_TRUE(isa<IntrinsicInst>(V));
 203   II = cast<IntrinsicInst>(V);
 204   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fdiv);
 205
 206   V = Builder.CreateFRem(V, V);
 207   ASSERT_TRUE(isa<IntrinsicInst>(V));
 208   II = cast<IntrinsicInst>(V);
 209   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_frem);
 210
 211   V = Builder.CreateFPTrunc(VDouble, Type::getFloatTy(Ctx));
 212   ASSERT_TRUE(isa<IntrinsicInst>(V));
 213   II = cast<IntrinsicInst>(V);
 214   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fptrunc);
 215
 216   VDouble = Builder.CreateFPExt(V, Type::getDoubleTy(Ctx));
 217   ASSERT_TRUE(isa<IntrinsicInst>(VDouble));
 218   II = cast<IntrinsicInst>(VDouble);
 219   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fpext);
 220
 221   // Verify the codepaths for setting and overriding the default metadata.
 222   V = Builder.CreateFAdd(V, V);
 223   ASSERT_TRUE(isa<ConstrainedFPIntrinsic>(V));
 224   auto *CII = cast<ConstrainedFPIntrinsic>(V);
 225   ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebStrict);
 226   ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmDynamic);
 227
 228   Builder.setDefaultConstrainedExcept(ConstrainedFPIntrinsic::ebIgnore);
 229   Builder.setDefaultConstrainedRounding(ConstrainedFPIntrinsic::rmUpward);
 230   V = Builder.CreateFAdd(V, V);
 231   CII = cast<ConstrainedFPIntrinsic>(V);
 232   ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebIgnore);
 233   ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmUpward);
 234
 235   Builder.setDefaultConstrainedExcept(ConstrainedFPIntrinsic::ebIgnore);
 236   Builder.setDefaultConstrainedRounding(ConstrainedFPIntrinsic::rmToNearest);
 237   V = Builder.CreateFAdd(V, V);
 238   CII = cast<ConstrainedFPIntrinsic>(V);
 239   ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebIgnore);
 240   ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmToNearest);
 241
 242   Builder.setDefaultConstrainedExcept(ConstrainedFPIntrinsic::ebMayTrap);
 243   Builder.setDefaultConstrainedRounding(ConstrainedFPIntrinsic::rmDownward);
 244   V = Builder.CreateFAdd(V, V);
 245   CII = cast<ConstrainedFPIntrinsic>(V);
 246   ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebMayTrap);
 247   ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmDownward);
 248
 249   Builder.setDefaultConstrainedExcept(ConstrainedFPIntrinsic::ebStrict);
 250   Builder.setDefaultConstrainedRounding(ConstrainedFPIntrinsic::rmTowardZero);
 251   V = Builder.CreateFAdd(V, V);
 252   CII = cast<ConstrainedFPIntrinsic>(V);
 253   ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebStrict);
 254   ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmTowardZero);
 255
 256   Builder.setDefaultConstrainedExcept(ConstrainedFPIntrinsic::ebIgnore);
 257   Builder.setDefaultConstrainedRounding(ConstrainedFPIntrinsic::rmDynamic);
 258   V = Builder.CreateFAdd(V, V);
 259   CII = cast<ConstrainedFPIntrinsic>(V);
 260   ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebIgnore);
 261   ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmDynamic);
 262
 263   // Now override the defaults.
 264   Call = Builder.CreateConstrainedFPBinOp(
 265         Intrinsic::experimental_constrained_fadd, V, V, nullptr, "", nullptr,
 266         ConstrainedFPIntrinsic::rmDownward, ConstrainedFPIntrinsic::ebMayTrap);
 267   CII = cast<ConstrainedFPIntrinsic>(Call);
 268   EXPECT_EQ(CII->getIntrinsicID(), Intrinsic::experimental_constrained_fadd);
 269   ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebMayTrap);
 270   ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmDownward);
 271
 272   Builder.CreateRetVoid();
 273   EXPECT_FALSE(verifyModule(*M));
 274 }
 275
 276 TEST_F(IRBuilderTest, Lifetime) {
 277   IRBuilder<> Builder(BB);
 278   AllocaInst *Var1 = Builder.CreateAlloca(Builder.getInt8Ty());
 279   AllocaInst *Var2 = Builder.CreateAlloca(Builder.getInt32Ty());
 280   AllocaInst *Var3 = Builder.CreateAlloca(Builder.getInt8Ty(),
 281                                           Builder.getInt32(123));
 282
 283   CallInst *Start1 = Builder.CreateLifetimeStart(Var1);
 284   CallInst *Start2 = Builder.CreateLifetimeStart(Var2);
 285   CallInst *Start3 = Builder.CreateLifetimeStart(Var3, Builder.getInt64(100));
 286
 287   EXPECT_EQ(Start1->getArgOperand(0), Builder.getInt64(-1));
 288   EXPECT_EQ(Start2->getArgOperand(0), Builder.getInt64(-1));
 289   EXPECT_EQ(Start3->getArgOperand(0), Builder.getInt64(100));
 290
 291   EXPECT_EQ(Start1->getArgOperand(1), Var1);
 292   EXPECT_NE(Start2->getArgOperand(1), Var2);
 293   EXPECT_EQ(Start3->getArgOperand(1), Var3);
 294
 295   Value *End1 = Builder.CreateLifetimeEnd(Var1);
 296   Builder.CreateLifetimeEnd(Var2);
 297   Builder.CreateLifetimeEnd(Var3);
 298
 299   IntrinsicInst *II_Start1 = dyn_cast<IntrinsicInst>(Start1);
 300   IntrinsicInst *II_End1 = dyn_cast<IntrinsicInst>(End1);
 301   ASSERT_TRUE(II_Start1 != nullptr);
 302   EXPECT_EQ(II_Start1->getIntrinsicID(), Intrinsic::lifetime_start);
 303   ASSERT_TRUE(II_End1 != nullptr);
 304   EXPECT_EQ(II_End1->getIntrinsicID(), Intrinsic::lifetime_end);
 305 }
 306
 307 TEST_F(IRBuilderTest, CreateCondBr) {
 308   IRBuilder<> Builder(BB);
 309   BasicBlock *TBB = BasicBlock::Create(Ctx, "", F);
 310   BasicBlock *FBB = BasicBlock::Create(Ctx, "", F);
 311
 312   BranchInst *BI = Builder.CreateCondBr(Builder.getTrue(), TBB, FBB);
 313   Instruction *TI = BB->getTerminator();
 314   EXPECT_EQ(BI, TI);
 315   EXPECT_EQ(2u, TI->getNumSuccessors());
 316   EXPECT_EQ(TBB, TI->getSuccessor(0));
 317   EXPECT_EQ(FBB, TI->getSuccessor(1));
 318
 319   BI->eraseFromParent();
 320   MDNode *Weights = MDBuilder(Ctx).createBranchWeights(42, 13);
 321   BI = Builder.CreateCondBr(Builder.getTrue(), TBB, FBB, Weights);
 322   TI = BB->getTerminator();
 323   EXPECT_EQ(BI, TI);
 324   EXPECT_EQ(2u, TI->getNumSuccessors());
 325   EXPECT_EQ(TBB, TI->getSuccessor(0));
 326   EXPECT_EQ(FBB, TI->getSuccessor(1));
 327   EXPECT_EQ(Weights, TI->getMetadata(LLVMContext::MD_prof));
 328 }
 329
 330 TEST_F(IRBuilderTest, LandingPadName) {
 331   IRBuilder<> Builder(BB);
 332   LandingPadInst *LP = Builder.CreateLandingPad(Builder.getInt32Ty(), 0, "LP");
 333   EXPECT_EQ(LP->getName(), "LP");
 334 }
 335
 336 TEST_F(IRBuilderTest, DataLayout) {
 337   std::unique_ptr<Module> M(new Module("test", Ctx));
 338   M->setDataLayout("e-n32");
 339   EXPECT_TRUE(M->getDataLayout().isLegalInteger(32));
 340   M->setDataLayout("e");
 341   EXPECT_FALSE(M->getDataLayout().isLegalInteger(32));
 342 }
 343
 344 TEST_F(IRBuilderTest, GetIntTy) {
 345   IRBuilder<> Builder(BB);
 346   IntegerType *Ty1 = Builder.getInt1Ty();
 347   EXPECT_EQ(Ty1, IntegerType::get(Ctx, 1));
 348
 349   DataLayout* DL = new DataLayout(M.get());
 350   IntegerType *IntPtrTy = Builder.getIntPtrTy(*DL);
 351   unsigned IntPtrBitSize =  DL->getPointerSizeInBits(0);
 352   EXPECT_EQ(IntPtrTy, IntegerType::get(Ctx, IntPtrBitSize));
 353   delete DL;
 354 }
 355
 356 TEST_F(IRBuilderTest, UnaryOperators) {
 357   IRBuilder<NoFolder> Builder(BB);
 358   Value *V = Builder.CreateLoad(GV->getValueType(), GV);
 359
 360   // Test CreateUnOp(X)
 361   Value *U = Builder.CreateUnOp(Instruction::FNeg, V);
 362   ASSERT_TRUE(isa<Instruction>(U));
 363   ASSERT_TRUE(isa<FPMathOperator>(U));
 364   ASSERT_TRUE(isa<UnaryOperator>(U));
 365   ASSERT_FALSE(isa<BinaryOperator>(U));
 366
 367   // Test CreateFNegFMF(X)
 368   Instruction *I = cast<Instruction>(V);
 369   I->setHasNoSignedZeros(true);
 370   I->setHasNoNaNs(true);
 371   Value *VFMF = Builder.CreateFNegFMF(V, I);
 372   Instruction *IFMF = cast<Instruction>(VFMF);
 373   EXPECT_TRUE(IFMF->hasNoSignedZeros());
 374   EXPECT_TRUE(IFMF->hasNoNaNs());
 375   EXPECT_FALSE(IFMF->hasAllowReassoc());
 376 }
 377
 378 TEST_F(IRBuilderTest, FastMathFlags) {
 379   IRBuilder<> Builder(BB);
 380   Value *F, *FC;
 381   Instruction *FDiv, *FAdd, *FCmp, *FCall;
 382
 383   F = Builder.CreateLoad(GV->getValueType(), GV);
 384   F = Builder.CreateFAdd(F, F);
 385
 386   EXPECT_FALSE(Builder.getFastMathFlags().any());
 387   ASSERT_TRUE(isa<Instruction>(F));
 388   FAdd = cast<Instruction>(F);
 389   EXPECT_FALSE(FAdd->hasNoNaNs());
 390
 391   FastMathFlags FMF;
 392   Builder.setFastMathFlags(FMF);
 393
 394   // By default, no flags are set.
 395   F = Builder.CreateFAdd(F, F);
 396   EXPECT_FALSE(Builder.getFastMathFlags().any());
 397   ASSERT_TRUE(isa<Instruction>(F));
 398   FAdd = cast<Instruction>(F);
 399   EXPECT_FALSE(FAdd->hasNoNaNs());
 400   EXPECT_FALSE(FAdd->hasNoInfs());
 401   EXPECT_FALSE(FAdd->hasNoSignedZeros());
 402   EXPECT_FALSE(FAdd->hasAllowReciprocal());
 403   EXPECT_FALSE(FAdd->hasAllowContract());
 404   EXPECT_FALSE(FAdd->hasAllowReassoc());
 405   EXPECT_FALSE(FAdd->hasApproxFunc());
 406
 407   // Set all flags in the instruction.
 408   FAdd->setFast(true);
 409   EXPECT_TRUE(FAdd->hasNoNaNs());
 410   EXPECT_TRUE(FAdd->hasNoInfs());
 411   EXPECT_TRUE(FAdd->hasNoSignedZeros());
 412   EXPECT_TRUE(FAdd->hasAllowReciprocal());
 413   EXPECT_TRUE(FAdd->hasAllowContract());
 414   EXPECT_TRUE(FAdd->hasAllowReassoc());
 415   EXPECT_TRUE(FAdd->hasApproxFunc());
 416
 417   // All flags are set in the builder.
 418   FMF.setFast();
 419   Builder.setFastMathFlags(FMF);
 420
 421   F = Builder.CreateFAdd(F, F);
 422   EXPECT_TRUE(Builder.getFastMathFlags().any());
 423   EXPECT_TRUE(Builder.getFastMathFlags().all());
 424   ASSERT_TRUE(isa<Instruction>(F));
 425   FAdd = cast<Instruction>(F);
 426   EXPECT_TRUE(FAdd->hasNoNaNs());
 427   EXPECT_TRUE(FAdd->isFast());
 428
 429   // Now, try it with CreateBinOp
 430   F = Builder.CreateBinOp(Instruction::FAdd, F, F);
 431   EXPECT_TRUE(Builder.getFastMathFlags().any());
 432   ASSERT_TRUE(isa<Instruction>(F));
 433   FAdd = cast<Instruction>(F);
 434   EXPECT_TRUE(FAdd->hasNoNaNs());
 435   EXPECT_TRUE(FAdd->isFast());
 436
 437   F = Builder.CreateFDiv(F, F);
 438   EXPECT_TRUE(Builder.getFastMathFlags().all());
 439   ASSERT_TRUE(isa<Instruction>(F));
 440   FDiv = cast<Instruction>(F);
 441   EXPECT_TRUE(FDiv->hasAllowReciprocal());
 442
 443   // Clear all FMF in the builder.
 444   Builder.clearFastMathFlags();
 445
 446   F = Builder.CreateFDiv(F, F);
 447   ASSERT_TRUE(isa<Instruction>(F));
 448   FDiv = cast<Instruction>(F);
 449   EXPECT_FALSE(FDiv->hasAllowReciprocal());
 450
 451   // Try individual flags.
 452   FMF.clear();
 453   FMF.setAllowReciprocal();
 454   Builder.setFastMathFlags(FMF);
 455
 456   F = Builder.CreateFDiv(F, F);
 457   EXPECT_TRUE(Builder.getFastMathFlags().any());
 458   EXPECT_TRUE(Builder.getFastMathFlags().AllowReciprocal);
 459   ASSERT_TRUE(isa<Instruction>(F));
 460   FDiv = cast<Instruction>(F);
 461   EXPECT_TRUE(FDiv->hasAllowReciprocal());
 462
 463   Builder.clearFastMathFlags();
 464
 465   FC = Builder.CreateFCmpOEQ(F, F);
 466   ASSERT_TRUE(isa<Instruction>(FC));
 467   FCmp = cast<Instruction>(FC);
 468   EXPECT_FALSE(FCmp->hasAllowReciprocal());
 469
 470   FMF.clear();
 471   FMF.setAllowReciprocal();
 472   Builder.setFastMathFlags(FMF);
 473
 474   FC = Builder.CreateFCmpOEQ(F, F);
 475   EXPECT_TRUE(Builder.getFastMathFlags().any());
 476   EXPECT_TRUE(Builder.getFastMathFlags().AllowReciprocal);
 477   ASSERT_TRUE(isa<Instruction>(FC));
 478   FCmp = cast<Instruction>(FC);
 479   EXPECT_TRUE(FCmp->hasAllowReciprocal());
 480
 481   Builder.clearFastMathFlags();
 482
 483   // Test FP-contract
 484   FC = Builder.CreateFAdd(F, F);
 485   ASSERT_TRUE(isa<Instruction>(FC));
 486   FAdd = cast<Instruction>(FC);
 487   EXPECT_FALSE(FAdd->hasAllowContract());
 488
 489   FMF.clear();
 490   FMF.setAllowContract(true);
 491   Builder.setFastMathFlags(FMF);
 492
 493   FC = Builder.CreateFAdd(F, F);
 494   EXPECT_TRUE(Builder.getFastMathFlags().any());
 495   EXPECT_TRUE(Builder.getFastMathFlags().AllowContract);
 496   ASSERT_TRUE(isa<Instruction>(FC));
 497   FAdd = cast<Instruction>(FC);
 498   EXPECT_TRUE(FAdd->hasAllowContract());
 499
 500   FMF.setApproxFunc();
 501   Builder.clearFastMathFlags();
 502   Builder.setFastMathFlags(FMF);
 503   // Now 'aml' and 'contract' are set.
 504   F = Builder.CreateFMul(F, F);
 505   FAdd = cast<Instruction>(F);
 506   EXPECT_TRUE(FAdd->hasApproxFunc());
 507   EXPECT_TRUE(FAdd->hasAllowContract());
 508   EXPECT_FALSE(FAdd->hasAllowReassoc());
 509
 510   FMF.setAllowReassoc();
 511   Builder.clearFastMathFlags();
 512   Builder.setFastMathFlags(FMF);
 513   // Now 'aml' and 'contract' and 'reassoc' are set.
 514   F = Builder.CreateFMul(F, F);
 515   FAdd = cast<Instruction>(F);
 516   EXPECT_TRUE(FAdd->hasApproxFunc());
 517   EXPECT_TRUE(FAdd->hasAllowContract());
 518   EXPECT_TRUE(FAdd->hasAllowReassoc());
 519
 520   // Test a call with FMF.
 521   auto CalleeTy = FunctionType::get(Type::getFloatTy(Ctx),
 522                                     /*isVarArg=*/false);
 523   auto Callee =
 524       Function::Create(CalleeTy, Function::ExternalLinkage, "", M.get());
 525
 526   FCall = Builder.CreateCall(Callee, None);
 527   EXPECT_FALSE(FCall->hasNoNaNs());
 528
 529   Function *V =
 530       Function::Create(CalleeTy, Function::ExternalLinkage, "", M.get());
 531   FCall = Builder.CreateCall(V, None);
 532   EXPECT_FALSE(FCall->hasNoNaNs());
 533
 534   FMF.clear();
 535   FMF.setNoNaNs();
 536   Builder.setFastMathFlags(FMF);
 537
 538   FCall = Builder.CreateCall(Callee, None);
 539   EXPECT_TRUE(Builder.getFastMathFlags().any());
 540   EXPECT_TRUE(Builder.getFastMathFlags().NoNaNs);
 541   EXPECT_TRUE(FCall->hasNoNaNs());
 542
 543   FCall = Builder.CreateCall(V, None);
 544   EXPECT_TRUE(Builder.getFastMathFlags().any());
 545   EXPECT_TRUE(Builder.getFastMathFlags().NoNaNs);
 546   EXPECT_TRUE(FCall->hasNoNaNs());
 547
 548   Builder.clearFastMathFlags();
 549
 550   // To test a copy, make sure that a '0' and a '1' change state.
 551   F = Builder.CreateFDiv(F, F);
 552   ASSERT_TRUE(isa<Instruction>(F));
 553   FDiv = cast<Instruction>(F);
 554   EXPECT_FALSE(FDiv->getFastMathFlags().any());
 555   FDiv->setHasAllowReciprocal(true);
 556   FAdd->setHasAllowReciprocal(false);
 557   FAdd->setHasNoNaNs(true);
 558   FDiv->copyFastMathFlags(FAdd);
 559   EXPECT_TRUE(FDiv->hasNoNaNs());
 560   EXPECT_FALSE(FDiv->hasAllowReciprocal());
 561
 562 }
 563
 564 TEST_F(IRBuilderTest, WrapFlags) {
 565   IRBuilder<NoFolder> Builder(BB);
 566
 567   // Test instructions.
 568   GlobalVariable *G = new GlobalVariable(*M, Builder.getInt32Ty(), true,
 569                                          GlobalValue::ExternalLinkage, nullptr);
 570   Value *V = Builder.CreateLoad(G->getValueType(), G);
 571   EXPECT_TRUE(
 572       cast<BinaryOperator>(Builder.CreateNSWAdd(V, V))->hasNoSignedWrap());
 573   EXPECT_TRUE(
 574       cast<BinaryOperator>(Builder.CreateNSWMul(V, V))->hasNoSignedWrap());
 575   EXPECT_TRUE(
 576       cast<BinaryOperator>(Builder.CreateNSWSub(V, V))->hasNoSignedWrap());
 577   EXPECT_TRUE(cast<BinaryOperator>(
 578                   Builder.CreateShl(V, V, "", /* NUW */ false, /* NSW */ true))
 579                   ->hasNoSignedWrap());
 580
 581   EXPECT_TRUE(
 582       cast<BinaryOperator>(Builder.CreateNUWAdd(V, V))->hasNoUnsignedWrap());
 583   EXPECT_TRUE(
 584       cast<BinaryOperator>(Builder.CreateNUWMul(V, V))->hasNoUnsignedWrap());
 585   EXPECT_TRUE(
 586       cast<BinaryOperator>(Builder.CreateNUWSub(V, V))->hasNoUnsignedWrap());
 587   EXPECT_TRUE(cast<BinaryOperator>(
 588                   Builder.CreateShl(V, V, "", /* NUW */ true, /* NSW */ false))
 589                   ->hasNoUnsignedWrap());
 590
 591   // Test operators created with constants.
 592   Constant *C = Builder.getInt32(42);
 593   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWAdd(C, C))
 594                   ->hasNoSignedWrap());
 595   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWSub(C, C))
 596                   ->hasNoSignedWrap());
 597   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWMul(C, C))
 598                   ->hasNoSignedWrap());
 599   EXPECT_TRUE(cast<OverflowingBinaryOperator>(
 600                   Builder.CreateShl(C, C, "", /* NUW */ false, /* NSW */ true))
 601                   ->hasNoSignedWrap());
 602
 603   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWAdd(C, C))
 604                   ->hasNoUnsignedWrap());
 605   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWSub(C, C))
 606                   ->hasNoUnsignedWrap());
 607   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWMul(C, C))
 608                   ->hasNoUnsignedWrap());
 609   EXPECT_TRUE(cast<OverflowingBinaryOperator>(
 610                   Builder.CreateShl(C, C, "", /* NUW */ true, /* NSW */ false))
 611                   ->hasNoUnsignedWrap());
 612 }
 613
 614 TEST_F(IRBuilderTest, RAIIHelpersTest) {
 615   IRBuilder<> Builder(BB);
 616   EXPECT_FALSE(Builder.getFastMathFlags().allowReciprocal());
 617   MDBuilder MDB(M->getContext());
 618
 619   MDNode *FPMathA = MDB.createFPMath(0.01f);
 620   MDNode *FPMathB = MDB.createFPMath(0.1f);
 621
 622   Builder.setDefaultFPMathTag(FPMathA);
 623
 624   {
 625     IRBuilder<>::FastMathFlagGuard Guard(Builder);
 626     FastMathFlags FMF;
 627     FMF.setAllowReciprocal();
 628     Builder.setFastMathFlags(FMF);
 629     Builder.setDefaultFPMathTag(FPMathB);
 630     EXPECT_TRUE(Builder.getFastMathFlags().allowReciprocal());
 631     EXPECT_EQ(FPMathB, Builder.getDefaultFPMathTag());
 632   }
 633
 634   EXPECT_FALSE(Builder.getFastMathFlags().allowReciprocal());
 635   EXPECT_EQ(FPMathA, Builder.getDefaultFPMathTag());
 636
 637   Value *F = Builder.CreateLoad(GV->getValueType(), GV);
 638
 639   {
 640     IRBuilder<>::InsertPointGuard Guard(Builder);
 641     Builder.SetInsertPoint(cast<Instruction>(F));
 642     EXPECT_EQ(F, &*Builder.GetInsertPoint());
 643   }
 644
 645   EXPECT_EQ(BB->end(), Builder.GetInsertPoint());
 646   EXPECT_EQ(BB, Builder.GetInsertBlock());
 647 }
 648
 649 TEST_F(IRBuilderTest, createFunction) {
 650   IRBuilder<> Builder(BB);
 651   DIBuilder DIB(*M);
 652   auto File = DIB.createFile("error.swift", "/");
 653   auto CU =
 654       DIB.createCompileUnit(dwarf::DW_LANG_Swift, File, "swiftc", true, "", 0);
 655   auto Type = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
 656   auto NoErr = DIB.createFunction(
 657       CU, "noerr", "", File, 1, Type, 1, DINode::FlagZero,
 658       DISubprogram::SPFlagDefinition | DISubprogram::SPFlagOptimized);
 659   EXPECT_TRUE(!NoErr->getThrownTypes());
 660   auto Int = DIB.createBasicType("Int", 64, dwarf::DW_ATE_signed);
 661   auto Error = DIB.getOrCreateArray({Int});
 662   auto Err = DIB.createFunction(
 663       CU, "err", "", File, 1, Type, 1, DINode::FlagZero,
 664       DISubprogram::SPFlagDefinition | DISubprogram::SPFlagOptimized, nullptr,
 665       nullptr, Error.get());
 666   EXPECT_TRUE(Err->getThrownTypes().get() == Error.get());
 667   DIB.finalize();
 668 }
 669
 670 TEST_F(IRBuilderTest, DIBuilder) {
 671   IRBuilder<> Builder(BB);
 672   DIBuilder DIB(*M);
 673   auto File = DIB.createFile("F.CBL", "/");
 674   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_Cobol74,
 675                                   DIB.createFile("F.CBL", "/"), "llvm-cobol74",
 676                                   true, "", 0);
 677   auto Type = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
 678   auto SP = DIB.createFunction(
 679       CU, "foo", "", File, 1, Type, 1, DINode::FlagZero,
 680       DISubprogram::SPFlagDefinition | DISubprogram::SPFlagOptimized);
 681   F->setSubprogram(SP);
 682   AllocaInst *I = Builder.CreateAlloca(Builder.getInt8Ty());
 683   auto BarSP = DIB.createFunction(
 684       CU, "bar", "", File, 1, Type, 1, DINode::FlagZero,
 685       DISubprogram::SPFlagDefinition | DISubprogram::SPFlagOptimized);
 686   auto BadScope = DIB.createLexicalBlockFile(BarSP, File, 0);
 687   I->setDebugLoc(DebugLoc::get(2, 0, BadScope));
 688   DIB.finalize();
 689   EXPECT_TRUE(verifyModule(*M));
 690 }
 691
 692 TEST_F(IRBuilderTest, createArtificialSubprogram) {
 693   IRBuilder<> Builder(BB);
 694   DIBuilder DIB(*M);
 695   auto File = DIB.createFile("main.c", "/");
 696   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_C, File, "clang",
 697                                   /*isOptimized=*/true, /*Flags=*/"",
 698                                   /*Runtime Version=*/0);
 699   auto Type = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
 700   auto SP = DIB.createFunction(
 701       CU, "foo", /*LinkageName=*/"", File,
 702       /*LineNo=*/1, Type, /*ScopeLine=*/2, DINode::FlagZero,
 703       DISubprogram::SPFlagDefinition | DISubprogram::SPFlagOptimized);
 704   EXPECT_TRUE(SP->isDistinct());
 705
 706   F->setSubprogram(SP);
 707   AllocaInst *I = Builder.CreateAlloca(Builder.getInt8Ty());
 708   ReturnInst *R = Builder.CreateRetVoid();
 709   I->setDebugLoc(DebugLoc::get(3, 2, SP));
 710   R->setDebugLoc(DebugLoc::get(4, 2, SP));
 711   DIB.finalize();
 712   EXPECT_FALSE(verifyModule(*M));
 713
 714   Function *G = Function::Create(F->getFunctionType(),
 715                                  Function::ExternalLinkage, "", M.get());
 716   BasicBlock *GBB = BasicBlock::Create(Ctx, "", G);
 717   Builder.SetInsertPoint(GBB);
 718   I->removeFromParent();
 719   Builder.Insert(I);
 720   Builder.CreateRetVoid();
 721   EXPECT_FALSE(verifyModule(*M));
 722
 723   DISubprogram *GSP = DIBuilder::createArtificialSubprogram(F->getSubprogram());
 724   EXPECT_EQ(SP->getFile(), GSP->getFile());
 725   EXPECT_EQ(SP->getType(), GSP->getType());
 726   EXPECT_EQ(SP->getLine(), GSP->getLine());
 727   EXPECT_EQ(SP->getScopeLine(), GSP->getScopeLine());
 728   EXPECT_TRUE(GSP->isDistinct());
 729
 730   G->setSubprogram(GSP);
 731   EXPECT_TRUE(verifyModule(*M));
 732
 733   auto *InlinedAtNode =
 734       DILocation::getDistinct(Ctx, GSP->getScopeLine(), 0, GSP);
 735   DebugLoc DL = I->getDebugLoc();
 736   DenseMap<const MDNode *, MDNode *> IANodes;
 737   auto IA = DebugLoc::appendInlinedAt(DL, InlinedAtNode, Ctx, IANodes);
 738   auto NewDL = DebugLoc::get(DL.getLine(), DL.getCol(), DL.getScope(), IA);
 739   I->setDebugLoc(NewDL);
 740   EXPECT_FALSE(verifyModule(*M));
 741
 742   EXPECT_EQ("foo", SP->getName());
 743   EXPECT_EQ("foo", GSP->getName());
 744   EXPECT_FALSE(SP->isArtificial());
 745   EXPECT_TRUE(GSP->isArtificial());
 746 }
 747
 748 TEST_F(IRBuilderTest, InsertExtractElement) {
 749   IRBuilder<> Builder(BB);
 750
 751   auto VecTy = VectorType::get(Builder.getInt64Ty(), 4);
 752   auto Elt1 = Builder.getInt64(-1);
 753   auto Elt2 = Builder.getInt64(-2);
 754   Value *Vec = UndefValue::get(VecTy);
 755   Vec = Builder.CreateInsertElement(Vec, Elt1, Builder.getInt8(1));
 756   Vec = Builder.CreateInsertElement(Vec, Elt2, 2);
 757   auto X1 = Builder.CreateExtractElement(Vec, 1);
 758   auto X2 = Builder.CreateExtractElement(Vec, Builder.getInt32(2));
 759   EXPECT_EQ(Elt1, X1);
 760   EXPECT_EQ(Elt2, X2);
 761 }
 762
 763 TEST_F(IRBuilderTest, CreateGlobalStringPtr) {
 764   IRBuilder<> Builder(BB);
 765
 766   auto String1a = Builder.CreateGlobalStringPtr("TestString", "String1a");
 767   auto String1b = Builder.CreateGlobalStringPtr("TestString", "String1b", 0);
 768   auto String2 = Builder.CreateGlobalStringPtr("TestString", "String2", 1);
 769   auto String3 = Builder.CreateGlobalString("TestString", "String3", 2);
 770
 771   EXPECT_TRUE(String1a->getType()->getPointerAddressSpace() == 0);
 772   EXPECT_TRUE(String1b->getType()->getPointerAddressSpace() == 0);
 773   EXPECT_TRUE(String2->getType()->getPointerAddressSpace() == 1);
 774   EXPECT_TRUE(String3->getType()->getPointerAddressSpace() == 2);
 775 }
 776
 777 TEST_F(IRBuilderTest, DebugLoc) {
 778   auto CalleeTy = FunctionType::get(Type::getVoidTy(Ctx),
 779                                     /*isVarArg=*/false);
 780   auto Callee =
 781       Function::Create(CalleeTy, Function::ExternalLinkage, "", M.get());
 782
 783   DIBuilder DIB(*M);
 784   auto File = DIB.createFile("tmp.cpp", "/");
 785   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_C_plus_plus_11,
 786                                   DIB.createFile("tmp.cpp", "/"), "", true, "",
 787                                   0);
 788   auto SPType = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
 789   auto SP =
 790       DIB.createFunction(CU, "foo", "foo", File, 1, SPType, 1, DINode::FlagZero,
 791                          DISubprogram::SPFlagDefinition);
 792   DebugLoc DL1 = DILocation::get(Ctx, 2, 0, SP);
 793   DebugLoc DL2 = DILocation::get(Ctx, 3, 0, SP);
 794
 795   auto BB2 = BasicBlock::Create(Ctx, "bb2", F);
 796   auto Br = BranchInst::Create(BB2, BB);
 797   Br->setDebugLoc(DL1);
 798
 799   IRBuilder<> Builder(Ctx);
 800   Builder.SetInsertPoint(Br);
 801   EXPECT_EQ(DL1, Builder.getCurrentDebugLocation());
 802   auto Call1 = Builder.CreateCall(Callee, None);
 803   EXPECT_EQ(DL1, Call1->getDebugLoc());
 804
 805   Call1->setDebugLoc(DL2);
 806   Builder.SetInsertPoint(Call1->getParent(), Call1->getIterator());
 807   EXPECT_EQ(DL2, Builder.getCurrentDebugLocation());
 808   auto Call2 = Builder.CreateCall(Callee, None);
 809   EXPECT_EQ(DL2, Call2->getDebugLoc());
 810
 811   DIB.finalize();
 812 }
 813
 814 TEST_F(IRBuilderTest, DIImportedEntity) {
 815   IRBuilder<> Builder(BB);
 816   DIBuilder DIB(*M);
 817   auto F = DIB.createFile("F.CBL", "/");
 818   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_Cobol74,
 819                                   F, "llvm-cobol74",
 820                                   true, "", 0);
 821   DIB.createImportedDeclaration(CU, nullptr, F, 1);
 822   DIB.createImportedDeclaration(CU, nullptr, F, 1);
 823   DIB.createImportedModule(CU, (DIImportedEntity *)nullptr, F, 2);
 824   DIB.createImportedModule(CU, (DIImportedEntity *)nullptr, F, 2);
 825   DIB.finalize();
 826   EXPECT_TRUE(verifyModule(*M));
 827   EXPECT_TRUE(CU->getImportedEntities().size() == 2);
 828 }
 829
 830 //  0: #define M0 V0          <-- command line definition
 831 //  0: main.c                 <-- main file
 832 //     3:   #define M1 V1     <-- M1 definition in main.c
 833 //     5:   #include "file.h" <-- inclusion of file.h from main.c
 834 //          1: #define M2     <-- M2 definition in file.h with no value
 835 //     7:   #undef M1 V1      <-- M1 un-definition in main.c
 836 TEST_F(IRBuilderTest, DIBuilderMacro) {
 837   IRBuilder<> Builder(BB);
 838   DIBuilder DIB(*M);
 839   auto File1 = DIB.createFile("main.c", "/");
 840   auto File2 = DIB.createFile("file.h", "/");
 841   auto CU = DIB.createCompileUnit(
 842       dwarf::DW_LANG_C, DIB.createFile("main.c", "/"), "llvm-c", true, "", 0);
 843   auto MDef0 =
 844       DIB.createMacro(nullptr, 0, dwarf::DW_MACINFO_define, "M0", "V0");
 845   auto TMF1 = DIB.createTempMacroFile(nullptr, 0, File1);
 846   auto MDef1 = DIB.createMacro(TMF1, 3, dwarf::DW_MACINFO_define, "M1", "V1");
 847   auto TMF2 = DIB.createTempMacroFile(TMF1, 5, File2);
 848   auto MDef2 = DIB.createMacro(TMF2, 1, dwarf::DW_MACINFO_define, "M2");
 849   auto MUndef1 = DIB.createMacro(TMF1, 7, dwarf::DW_MACINFO_undef, "M1");
 850
 851   EXPECT_EQ(dwarf::DW_MACINFO_define, MDef1->getMacinfoType());
 852   EXPECT_EQ(3u, MDef1->getLine());
 853   EXPECT_EQ("M1", MDef1->getName());
 854   EXPECT_EQ("V1", MDef1->getValue());
 855
 856   EXPECT_EQ(dwarf::DW_MACINFO_undef, MUndef1->getMacinfoType());
 857   EXPECT_EQ(7u, MUndef1->getLine());
 858   EXPECT_EQ("M1", MUndef1->getName());
 859   EXPECT_EQ("", MUndef1->getValue());
 860
 861   EXPECT_EQ(dwarf::DW_MACINFO_start_file, TMF2->getMacinfoType());
 862   EXPECT_EQ(5u, TMF2->getLine());
 863   EXPECT_EQ(File2, TMF2->getFile());
 864
 865   DIB.finalize();
 866
 867   SmallVector<Metadata *, 4> Elements;
 868   Elements.push_back(MDef2);
 869   auto MF2 = DIMacroFile::get(Ctx, dwarf::DW_MACINFO_start_file, 5, File2,
 870                               DIB.getOrCreateMacroArray(Elements));
 871
 872   Elements.clear();
 873   Elements.push_back(MDef1);
 874   Elements.push_back(MF2);
 875   Elements.push_back(MUndef1);
 876   auto MF1 = DIMacroFile::get(Ctx, dwarf::DW_MACINFO_start_file, 0, File1,
 877                               DIB.getOrCreateMacroArray(Elements));
 878
 879   Elements.clear();
 880   Elements.push_back(MDef0);
 881   Elements.push_back(MF1);
 882   auto MN0 = MDTuple::get(Ctx, Elements);
 883   EXPECT_EQ(MN0, CU->getRawMacros());
 884
 885   Elements.clear();
 886   Elements.push_back(MDef1);
 887   Elements.push_back(MF2);
 888   Elements.push_back(MUndef1);
 889   auto MN1 = MDTuple::get(Ctx, Elements);
 890   EXPECT_EQ(MN1, MF1->getRawElements());
 891
 892   Elements.clear();
 893   Elements.push_back(MDef2);
 894   auto MN2 = MDTuple::get(Ctx, Elements);
 895   EXPECT_EQ(MN2, MF2->getRawElements());
 896   EXPECT_TRUE(verifyModule(*M));
 897 }
 898 }