llvm/unittests/Transforms/Utils/CloningTest.cpp

   1 //===- Cloning.cpp - Unit tests for the Cloner ----------------------------===//
   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/Transforms/Utils/Cloning.h"
  10 #include "llvm/ADT/STLExtras.h"
  11 #include "llvm/ADT/SmallPtrSet.h"
  12 #include "llvm/Analysis/AliasAnalysis.h"
  13 #include "llvm/Analysis/DomTreeUpdater.h"
  14 #include "llvm/Analysis/LoopInfo.h"
  15 #include "llvm/AsmParser/Parser.h"
  16 #include "llvm/IR/Argument.h"
  17 #include "llvm/IR/Constant.h"
  18 #include "llvm/IR/DIBuilder.h"
  19 #include "llvm/IR/DebugInfo.h"
  20 #include "llvm/IR/Function.h"
  21 #include "llvm/IR/IRBuilder.h"
  22 #include "llvm/IR/InstIterator.h"
  23 #include "llvm/IR/Instructions.h"
  24 #include "llvm/IR/IntrinsicInst.h"
  25 #include "llvm/IR/LLVMContext.h"
  26 #include "llvm/IR/Module.h"
  27 #include "llvm/IR/Verifier.h"
  28 #include "llvm/Support/SourceMgr.h"
  29 #include "gtest/gtest.h"
  30
  31 using namespace llvm;
  32
  33 namespace {
  34
  35 class CloneInstruction : public ::testing::Test {
  36 protected:
  37   void SetUp() override { V = nullptr; }
  38
  39   template <typename T>
  40   T *clone(T *V1) {
  41     Value *V2 = V1->clone();
  42     Orig.insert(V1);
  43     Clones.insert(V2);
  44     return cast<T>(V2);
  45   }
  46
  47   void eraseClones() {
  48     for (Value *V : Clones)
  49       V->deleteValue();
  50     Clones.clear();
  51   }
  52
  53   void TearDown() override {
  54     eraseClones();
  55     for (Value *V : Orig)
  56       V->deleteValue();
  57     Orig.clear();
  58     if (V)
  59       V->deleteValue();
  60   }
  61
  62   SmallPtrSet<Value *, 4> Orig;   // Erase on exit
  63   SmallPtrSet<Value *, 4> Clones; // Erase in eraseClones
  64
  65   LLVMContext context;
  66   Value *V;
  67 };
  68
  69 TEST_F(CloneInstruction, OverflowBits) {
  70   V = new Argument(Type::getInt32Ty(context));
  71
  72   BinaryOperator *Add = BinaryOperator::Create(Instruction::Add, V, V);
  73   BinaryOperator *Sub = BinaryOperator::Create(Instruction::Sub, V, V);
  74   BinaryOperator *Mul = BinaryOperator::Create(Instruction::Mul, V, V);
  75
  76   BinaryOperator *AddClone = this->clone(Add);
  77   BinaryOperator *SubClone = this->clone(Sub);
  78   BinaryOperator *MulClone = this->clone(Mul);
  79
  80   EXPECT_FALSE(AddClone->hasNoUnsignedWrap());
  81   EXPECT_FALSE(AddClone->hasNoSignedWrap());
  82   EXPECT_FALSE(SubClone->hasNoUnsignedWrap());
  83   EXPECT_FALSE(SubClone->hasNoSignedWrap());
  84   EXPECT_FALSE(MulClone->hasNoUnsignedWrap());
  85   EXPECT_FALSE(MulClone->hasNoSignedWrap());
  86
  87   eraseClones();
  88
  89   Add->setHasNoUnsignedWrap();
  90   Sub->setHasNoUnsignedWrap();
  91   Mul->setHasNoUnsignedWrap();
  92
  93   AddClone = this->clone(Add);
  94   SubClone = this->clone(Sub);
  95   MulClone = this->clone(Mul);
  96
  97   EXPECT_TRUE(AddClone->hasNoUnsignedWrap());
  98   EXPECT_FALSE(AddClone->hasNoSignedWrap());
  99   EXPECT_TRUE(SubClone->hasNoUnsignedWrap());
 100   EXPECT_FALSE(SubClone->hasNoSignedWrap());
 101   EXPECT_TRUE(MulClone->hasNoUnsignedWrap());
 102   EXPECT_FALSE(MulClone->hasNoSignedWrap());
 103
 104   eraseClones();
 105
 106   Add->setHasNoSignedWrap();
 107   Sub->setHasNoSignedWrap();
 108   Mul->setHasNoSignedWrap();
 109
 110   AddClone = this->clone(Add);
 111   SubClone = this->clone(Sub);
 112   MulClone = this->clone(Mul);
 113
 114   EXPECT_TRUE(AddClone->hasNoUnsignedWrap());
 115   EXPECT_TRUE(AddClone->hasNoSignedWrap());
 116   EXPECT_TRUE(SubClone->hasNoUnsignedWrap());
 117   EXPECT_TRUE(SubClone->hasNoSignedWrap());
 118   EXPECT_TRUE(MulClone->hasNoUnsignedWrap());
 119   EXPECT_TRUE(MulClone->hasNoSignedWrap());
 120
 121   eraseClones();
 122
 123   Add->setHasNoUnsignedWrap(false);
 124   Sub->setHasNoUnsignedWrap(false);
 125   Mul->setHasNoUnsignedWrap(false);
 126
 127   AddClone = this->clone(Add);
 128   SubClone = this->clone(Sub);
 129   MulClone = this->clone(Mul);
 130
 131   EXPECT_FALSE(AddClone->hasNoUnsignedWrap());
 132   EXPECT_TRUE(AddClone->hasNoSignedWrap());
 133   EXPECT_FALSE(SubClone->hasNoUnsignedWrap());
 134   EXPECT_TRUE(SubClone->hasNoSignedWrap());
 135   EXPECT_FALSE(MulClone->hasNoUnsignedWrap());
 136   EXPECT_TRUE(MulClone->hasNoSignedWrap());
 137 }
 138
 139 TEST_F(CloneInstruction, Inbounds) {
 140   V = new Argument(Type::getInt32PtrTy(context));
 141
 142   Constant *Z = Constant::getNullValue(Type::getInt32Ty(context));
 143   std::vector<Value *> ops;
 144   ops.push_back(Z);
 145   GetElementPtrInst *GEP =
 146       GetElementPtrInst::Create(Type::getInt32Ty(context), V, ops);
 147   EXPECT_FALSE(this->clone(GEP)->isInBounds());
 148
 149   GEP->setIsInBounds();
 150   EXPECT_TRUE(this->clone(GEP)->isInBounds());
 151 }
 152
 153 TEST_F(CloneInstruction, Exact) {
 154   V = new Argument(Type::getInt32Ty(context));
 155
 156   BinaryOperator *SDiv = BinaryOperator::Create(Instruction::SDiv, V, V);
 157   EXPECT_FALSE(this->clone(SDiv)->isExact());
 158
 159   SDiv->setIsExact(true);
 160   EXPECT_TRUE(this->clone(SDiv)->isExact());
 161 }
 162
 163 TEST_F(CloneInstruction, Attributes) {
 164   Type *ArgTy1[] = { Type::getInt32PtrTy(context) };
 165   FunctionType *FT1 =  FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
 166
 167   Function *F1 = Function::Create(FT1, Function::ExternalLinkage);
 168   BasicBlock *BB = BasicBlock::Create(context, "", F1);
 169   IRBuilder<> Builder(BB);
 170   Builder.CreateRetVoid();
 171
 172   Function *F2 = Function::Create(FT1, Function::ExternalLinkage);
 173
 174   Argument *A = &*F1->arg_begin();
 175   A->addAttr(Attribute::NoCapture);
 176
 177   SmallVector<ReturnInst*, 4> Returns;
 178   ValueToValueMapTy VMap;
 179   VMap[A] = UndefValue::get(A->getType());
 180
 181   CloneFunctionInto(F2, F1, VMap, CloneFunctionChangeType::LocalChangesOnly,
 182                     Returns);
 183   EXPECT_FALSE(F2->arg_begin()->hasNoCaptureAttr());
 184
 185   delete F1;
 186   delete F2;
 187 }
 188
 189 TEST_F(CloneInstruction, CallingConvention) {
 190   Type *ArgTy1[] = { Type::getInt32PtrTy(context) };
 191   FunctionType *FT1 =  FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
 192
 193   Function *F1 = Function::Create(FT1, Function::ExternalLinkage);
 194   F1->setCallingConv(CallingConv::Cold);
 195   BasicBlock *BB = BasicBlock::Create(context, "", F1);
 196   IRBuilder<> Builder(BB);
 197   Builder.CreateRetVoid();
 198
 199   Function *F2 = Function::Create(FT1, Function::ExternalLinkage);
 200
 201   SmallVector<ReturnInst*, 4> Returns;
 202   ValueToValueMapTy VMap;
 203   VMap[&*F1->arg_begin()] = &*F2->arg_begin();
 204
 205   CloneFunctionInto(F2, F1, VMap, CloneFunctionChangeType::LocalChangesOnly,
 206                     Returns);
 207   EXPECT_EQ(CallingConv::Cold, F2->getCallingConv());
 208
 209   delete F1;
 210   delete F2;
 211 }
 212
 213 TEST_F(CloneInstruction, DuplicateInstructionsToSplit) {
 214   Type *ArgTy1[] = {Type::getInt32PtrTy(context)};
 215   FunctionType *FT = FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
 216   V = new Argument(Type::getInt32Ty(context));
 217
 218   Function *F = Function::Create(FT, Function::ExternalLinkage);
 219
 220   BasicBlock *BB1 = BasicBlock::Create(context, "", F);
 221   IRBuilder<> Builder1(BB1);
 222
 223   BasicBlock *BB2 = BasicBlock::Create(context, "", F);
 224   IRBuilder<> Builder2(BB2);
 225
 226   Builder1.CreateBr(BB2);
 227
 228   Instruction *AddInst = cast<Instruction>(Builder2.CreateAdd(V, V));
 229   Instruction *MulInst = cast<Instruction>(Builder2.CreateMul(AddInst, V));
 230   Instruction *SubInst = cast<Instruction>(Builder2.CreateSub(MulInst, V));
 231   Builder2.CreateRetVoid();
 232
 233   // Dummy DTU.
 234   ValueToValueMapTy Mapping;
 235   DomTreeUpdater DTU(DomTreeUpdater::UpdateStrategy::Lazy);
 236   auto Split =
 237       DuplicateInstructionsInSplitBetween(BB2, BB1, SubInst, Mapping, DTU);
 238
 239   EXPECT_TRUE(Split);
 240   EXPECT_EQ(Mapping.size(), 2u);
 241   EXPECT_TRUE(Mapping.find(AddInst) != Mapping.end());
 242   EXPECT_TRUE(Mapping.find(MulInst) != Mapping.end());
 243
 244   auto AddSplit = dyn_cast<Instruction>(Mapping[AddInst]);
 245   EXPECT_TRUE(AddSplit);
 246   EXPECT_EQ(AddSplit->getOperand(0), V);
 247   EXPECT_EQ(AddSplit->getOperand(1), V);
 248   EXPECT_EQ(AddSplit->getParent(), Split);
 249
 250   auto MulSplit = dyn_cast<Instruction>(Mapping[MulInst]);
 251   EXPECT_TRUE(MulSplit);
 252   EXPECT_EQ(MulSplit->getOperand(0), AddSplit);
 253   EXPECT_EQ(MulSplit->getOperand(1), V);
 254   EXPECT_EQ(MulSplit->getParent(), Split);
 255
 256   EXPECT_EQ(AddSplit->getNextNode(), MulSplit);
 257   EXPECT_EQ(MulSplit->getNextNode(), Split->getTerminator());
 258
 259   delete F;
 260 }
 261
 262 TEST_F(CloneInstruction, DuplicateInstructionsToSplitBlocksEq1) {
 263   Type *ArgTy1[] = {Type::getInt32PtrTy(context)};
 264   FunctionType *FT = FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
 265   V = new Argument(Type::getInt32Ty(context));
 266
 267   Function *F = Function::Create(FT, Function::ExternalLinkage);
 268
 269   BasicBlock *BB1 = BasicBlock::Create(context, "", F);
 270   IRBuilder<> Builder1(BB1);
 271
 272   BasicBlock *BB2 = BasicBlock::Create(context, "", F);
 273   IRBuilder<> Builder2(BB2);
 274
 275   Builder1.CreateBr(BB2);
 276
 277   Instruction *AddInst = cast<Instruction>(Builder2.CreateAdd(V, V));
 278   Instruction *MulInst = cast<Instruction>(Builder2.CreateMul(AddInst, V));
 279   Instruction *SubInst = cast<Instruction>(Builder2.CreateSub(MulInst, V));
 280   Builder2.CreateBr(BB2);
 281
 282   // Dummy DTU.
 283   DomTreeUpdater DTU(DomTreeUpdater::UpdateStrategy::Lazy);
 284   ValueToValueMapTy Mapping;
 285   auto Split = DuplicateInstructionsInSplitBetween(
 286       BB2, BB2, BB2->getTerminator(), Mapping, DTU);
 287
 288   EXPECT_TRUE(Split);
 289   EXPECT_EQ(Mapping.size(), 3u);
 290   EXPECT_TRUE(Mapping.find(AddInst) != Mapping.end());
 291   EXPECT_TRUE(Mapping.find(MulInst) != Mapping.end());
 292   EXPECT_TRUE(Mapping.find(SubInst) != Mapping.end());
 293
 294   auto AddSplit = dyn_cast<Instruction>(Mapping[AddInst]);
 295   EXPECT_TRUE(AddSplit);
 296   EXPECT_EQ(AddSplit->getOperand(0), V);
 297   EXPECT_EQ(AddSplit->getOperand(1), V);
 298   EXPECT_EQ(AddSplit->getParent(), Split);
 299
 300   auto MulSplit = dyn_cast<Instruction>(Mapping[MulInst]);
 301   EXPECT_TRUE(MulSplit);
 302   EXPECT_EQ(MulSplit->getOperand(0), AddSplit);
 303   EXPECT_EQ(MulSplit->getOperand(1), V);
 304   EXPECT_EQ(MulSplit->getParent(), Split);
 305
 306   auto SubSplit = dyn_cast<Instruction>(Mapping[SubInst]);
 307   EXPECT_EQ(MulSplit->getNextNode(), SubSplit);
 308   EXPECT_EQ(SubSplit->getNextNode(), Split->getTerminator());
 309   EXPECT_EQ(Split->getSingleSuccessor(), BB2);
 310   EXPECT_EQ(BB2->getSingleSuccessor(), Split);
 311
 312   delete F;
 313 }
 314
 315 TEST_F(CloneInstruction, DuplicateInstructionsToSplitBlocksEq2) {
 316   Type *ArgTy1[] = {Type::getInt32PtrTy(context)};
 317   FunctionType *FT = FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
 318   V = new Argument(Type::getInt32Ty(context));
 319
 320   Function *F = Function::Create(FT, Function::ExternalLinkage);
 321
 322   BasicBlock *BB1 = BasicBlock::Create(context, "", F);
 323   IRBuilder<> Builder1(BB1);
 324
 325   BasicBlock *BB2 = BasicBlock::Create(context, "", F);
 326   IRBuilder<> Builder2(BB2);
 327
 328   Builder1.CreateBr(BB2);
 329
 330   Instruction *AddInst = cast<Instruction>(Builder2.CreateAdd(V, V));
 331   Instruction *MulInst = cast<Instruction>(Builder2.CreateMul(AddInst, V));
 332   Instruction *SubInst = cast<Instruction>(Builder2.CreateSub(MulInst, V));
 333   Builder2.CreateBr(BB2);
 334
 335   // Dummy DTU.
 336   DomTreeUpdater DTU(DomTreeUpdater::UpdateStrategy::Lazy);
 337   ValueToValueMapTy Mapping;
 338   auto Split =
 339       DuplicateInstructionsInSplitBetween(BB2, BB2, SubInst, Mapping, DTU);
 340
 341   EXPECT_TRUE(Split);
 342   EXPECT_EQ(Mapping.size(), 2u);
 343   EXPECT_TRUE(Mapping.find(AddInst) != Mapping.end());
 344   EXPECT_TRUE(Mapping.find(MulInst) != Mapping.end());
 345
 346   auto AddSplit = dyn_cast<Instruction>(Mapping[AddInst]);
 347   EXPECT_TRUE(AddSplit);
 348   EXPECT_EQ(AddSplit->getOperand(0), V);
 349   EXPECT_EQ(AddSplit->getOperand(1), V);
 350   EXPECT_EQ(AddSplit->getParent(), Split);
 351
 352   auto MulSplit = dyn_cast<Instruction>(Mapping[MulInst]);
 353   EXPECT_TRUE(MulSplit);
 354   EXPECT_EQ(MulSplit->getOperand(0), AddSplit);
 355   EXPECT_EQ(MulSplit->getOperand(1), V);
 356   EXPECT_EQ(MulSplit->getParent(), Split);
 357   EXPECT_EQ(MulSplit->getNextNode(), Split->getTerminator());
 358   EXPECT_EQ(Split->getSingleSuccessor(), BB2);
 359   EXPECT_EQ(BB2->getSingleSuccessor(), Split);
 360
 361   delete F;
 362 }
 363
 364 static void runWithLoopInfoAndDominatorTree(
 365     Module &M, StringRef FuncName,
 366     function_ref<void(Function &F, LoopInfo &LI, DominatorTree &DT)> Test) {
 367   auto *F = M.getFunction(FuncName);
 368   ASSERT_NE(F, nullptr) << "Could not find " << FuncName;
 369
 370   DominatorTree DT(*F);
 371   LoopInfo LI(DT);
 372
 373   Test(*F, LI, DT);
 374 }
 375
 376 static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
 377   SMDiagnostic Err;
 378   std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
 379   if (!Mod)
 380     Err.print("CloneLoop", errs());
 381   return Mod;
 382 }
 383
 384 TEST(CloneLoop, CloneLoopNest) {
 385   // Parse the module.
 386   LLVMContext Context;
 387
 388   std::unique_ptr<Module> M = parseIR(
 389     Context,
 390     R"(define void @foo(i32* %A, i32 %ub) {
 391 entry:
 392   %guardcmp = icmp slt i32 0, %ub
 393   br i1 %guardcmp, label %for.outer.preheader, label %for.end
 394 for.outer.preheader:
 395   br label %for.outer
 396 for.outer:
 397   %j = phi i32 [ 0, %for.outer.preheader ], [ %inc.outer, %for.outer.latch ]
 398   br i1 %guardcmp, label %for.inner.preheader, label %for.outer.latch
 399 for.inner.preheader:
 400   br label %for.inner
 401 for.inner:
 402   %i = phi i32 [ 0, %for.inner.preheader ], [ %inc, %for.inner ]
 403   %idxprom = sext i32 %i to i64
 404   %arrayidx = getelementptr inbounds i32, i32* %A, i64 %idxprom
 405   store i32 %i, i32* %arrayidx, align 4
 406   %inc = add nsw i32 %i, 1
 407   %cmp = icmp slt i32 %inc, %ub
 408   br i1 %cmp, label %for.inner, label %for.inner.exit
 409 for.inner.exit:
 410   br label %for.outer.latch
 411 for.outer.latch:
 412   %inc.outer = add nsw i32 %j, 1
 413   %cmp.outer = icmp slt i32 %inc.outer, %ub
 414   br i1 %cmp.outer, label %for.outer, label %for.outer.exit
 415 for.outer.exit:
 416   br label %for.end
 417 for.end:
 418   ret void
 419 })"
 420     );
 421
 422   runWithLoopInfoAndDominatorTree(
 423       *M, "foo", [&](Function &F, LoopInfo &LI, DominatorTree &DT) {
 424         Function::iterator FI = F.begin();
 425         // First basic block is entry - skip it.
 426         BasicBlock *Preheader = &*(++FI);
 427         BasicBlock *Header = &*(++FI);
 428         assert(Header->getName() == "for.outer");
 429         Loop *L = LI.getLoopFor(Header);
 430         EXPECT_NE(L, nullptr);
 431         EXPECT_EQ(Header, L->getHeader());
 432         EXPECT_EQ(Preheader, L->getLoopPreheader());
 433
 434         ValueToValueMapTy VMap;
 435         SmallVector<BasicBlock *, 4> ClonedLoopBlocks;
 436         Loop *NewLoop = cloneLoopWithPreheader(Preheader, Preheader, L, VMap,
 437                                                "", &LI, &DT, ClonedLoopBlocks);
 438         EXPECT_NE(NewLoop, nullptr);
 439         EXPECT_EQ(NewLoop->getSubLoops().size(), 1u);
 440         Loop::block_iterator BI = NewLoop->block_begin();
 441         EXPECT_TRUE((*BI)->getName().startswith("for.outer"));
 442         EXPECT_TRUE((*(++BI))->getName().startswith("for.inner.preheader"));
 443         EXPECT_TRUE((*(++BI))->getName().startswith("for.inner"));
 444         EXPECT_TRUE((*(++BI))->getName().startswith("for.inner.exit"));
 445         EXPECT_TRUE((*(++BI))->getName().startswith("for.outer.latch"));
 446       });
 447 }
 448
 449 class CloneFunc : public ::testing::Test {
 450 protected:
 451   void SetUp() override {
 452     SetupModule();
 453     CreateOldFunc();
 454     CreateNewFunc();
 455     SetupFinder();
 456   }
 457
 458   void TearDown() override { delete Finder; }
 459
 460   void SetupModule() {
 461     M = new Module("", C);
 462   }
 463
 464   void CreateOldFunc() {
 465     FunctionType* FuncType = FunctionType::get(Type::getVoidTy(C), false);
 466     OldFunc = Function::Create(FuncType, GlobalValue::PrivateLinkage, "f", M);
 467     CreateOldFunctionBodyAndDI();
 468   }
 469
 470   void CreateOldFunctionBodyAndDI() {
 471     DIBuilder DBuilder(*M);
 472     IRBuilder<> IBuilder(C);
 473
 474     // Function DI
 475     auto *File = DBuilder.createFile("filename.c", "/file/dir/");
 476     DITypeRefArray ParamTypes = DBuilder.getOrCreateTypeArray(None);
 477     DISubroutineType *FuncType =
 478         DBuilder.createSubroutineType(ParamTypes);
 479     auto *CU = DBuilder.createCompileUnit(dwarf::DW_LANG_C99,
 480                                           DBuilder.createFile("filename.c",
 481                                                               "/file/dir"),
 482                                           "CloneFunc", false, "", 0);
 483
 484     auto *Subprogram = DBuilder.createFunction(
 485         CU, "f", "f", File, 4, FuncType, 3, DINode::FlagZero,
 486         DISubprogram::SPFlagLocalToUnit | DISubprogram::SPFlagDefinition);
 487     OldFunc->setSubprogram(Subprogram);
 488
 489     // Function body
 490     BasicBlock* Entry = BasicBlock::Create(C, "", OldFunc);
 491     IBuilder.SetInsertPoint(Entry);
 492     DebugLoc Loc = DILocation::get(Subprogram->getContext(), 3, 2, Subprogram);
 493     IBuilder.SetCurrentDebugLocation(Loc);
 494     AllocaInst* Alloca = IBuilder.CreateAlloca(IntegerType::getInt32Ty(C));
 495     IBuilder.SetCurrentDebugLocation(
 496         DILocation::get(Subprogram->getContext(), 4, 2, Subprogram));
 497     Value* AllocaContent = IBuilder.getInt32(1);
 498     Instruction* Store = IBuilder.CreateStore(AllocaContent, Alloca);
 499     IBuilder.SetCurrentDebugLocation(
 500         DILocation::get(Subprogram->getContext(), 5, 2, Subprogram));
 501
 502     // Create a local variable around the alloca
 503     auto *IntType = DBuilder.createBasicType("int", 32, dwarf::DW_ATE_signed);
 504     auto *E = DBuilder.createExpression();
 505     auto *Variable =
 506         DBuilder.createAutoVariable(Subprogram, "x", File, 5, IntType, true);
 507     auto *DL = DILocation::get(Subprogram->getContext(), 5, 0, Subprogram);
 508     DBuilder.insertDeclare(Alloca, Variable, E, DL, Store);
 509     DBuilder.insertDbgValueIntrinsic(AllocaContent, Variable, E, DL, Entry);
 510     // Also create an inlined variable.
 511     // Create a distinct struct type that we should not duplicate during
 512     // cloning).
 513     auto *StructType = DICompositeType::getDistinct(
 514         C, dwarf::DW_TAG_structure_type, "some_struct", nullptr, 0, nullptr,
 515         nullptr, 32, 32, 0, DINode::FlagZero, nullptr, 0, nullptr, nullptr);
 516     auto *InlinedSP = DBuilder.createFunction(
 517         CU, "inlined", "inlined", File, 8, FuncType, 9, DINode::FlagZero,
 518         DISubprogram::SPFlagLocalToUnit | DISubprogram::SPFlagDefinition);
 519     auto *InlinedVar =
 520         DBuilder.createAutoVariable(InlinedSP, "inlined", File, 5, StructType, true);
 521     auto *Scope = DBuilder.createLexicalBlock(
 522         DBuilder.createLexicalBlockFile(InlinedSP, File), File, 1, 1);
 523     auto InlinedDL = DILocation::get(
 524         Subprogram->getContext(), 9, 4, Scope,
 525         DILocation::get(Subprogram->getContext(), 5, 2, Subprogram));
 526     IBuilder.SetCurrentDebugLocation(InlinedDL);
 527     DBuilder.insertDeclare(Alloca, InlinedVar, E, InlinedDL, Store);
 528     IBuilder.CreateStore(IBuilder.getInt32(2), Alloca);
 529     // Finalize the debug info.
 530     DBuilder.finalize();
 531     IBuilder.CreateRetVoid();
 532
 533     // Create another, empty, compile unit.
 534     DIBuilder DBuilder2(*M);
 535     DBuilder2.createCompileUnit(dwarf::DW_LANG_C99,
 536                                 DBuilder.createFile("extra.c", "/file/dir"),
 537                                 "CloneFunc", false, "", 0);
 538     DBuilder2.finalize();
 539   }
 540
 541   void CreateNewFunc() {
 542     ValueToValueMapTy VMap;
 543     NewFunc = CloneFunction(OldFunc, VMap, nullptr);
 544   }
 545
 546   void SetupFinder() {
 547     Finder = new DebugInfoFinder();
 548     Finder->processModule(*M);
 549   }
 550
 551   LLVMContext C;
 552   Function* OldFunc;
 553   Function* NewFunc;
 554   Module* M;
 555   DebugInfoFinder* Finder;
 556 };
 557
 558 // Test that a new, distinct function was created.
 559 TEST_F(CloneFunc, NewFunctionCreated) {
 560   EXPECT_NE(OldFunc, NewFunc);
 561 }
 562
 563 // Test that a new subprogram entry was added and is pointing to the new
 564 // function, while the original subprogram still points to the old one.
 565 TEST_F(CloneFunc, Subprogram) {
 566   EXPECT_FALSE(verifyModule(*M, &errs()));
 567   EXPECT_EQ(3U, Finder->subprogram_count());
 568   EXPECT_NE(NewFunc->getSubprogram(), OldFunc->getSubprogram());
 569 }
 570
 571 // Test that instructions in the old function still belong to it in the
 572 // metadata, while instruction in the new function belong to the new one.
 573 TEST_F(CloneFunc, InstructionOwnership) {
 574   EXPECT_FALSE(verifyModule(*M));
 575
 576   inst_iterator OldIter = inst_begin(OldFunc);
 577   inst_iterator OldEnd = inst_end(OldFunc);
 578   inst_iterator NewIter = inst_begin(NewFunc);
 579   inst_iterator NewEnd = inst_end(NewFunc);
 580   while (OldIter != OldEnd && NewIter != NewEnd) {
 581     Instruction& OldI = *OldIter;
 582     Instruction& NewI = *NewIter;
 583     EXPECT_NE(&OldI, &NewI);
 584
 585     EXPECT_EQ(OldI.hasMetadata(), NewI.hasMetadata());
 586     if (OldI.hasMetadata()) {
 587       const DebugLoc& OldDL = OldI.getDebugLoc();
 588       const DebugLoc& NewDL = NewI.getDebugLoc();
 589
 590       // Verify that the debug location data is the same
 591       EXPECT_EQ(OldDL.getLine(), NewDL.getLine());
 592       EXPECT_EQ(OldDL.getCol(), NewDL.getCol());
 593
 594       // But that they belong to different functions
 595       auto *OldSubprogram = cast<DISubprogram>(OldDL.getInlinedAtScope());
 596       auto *NewSubprogram = cast<DISubprogram>(NewDL.getInlinedAtScope());
 597       EXPECT_EQ(OldFunc->getSubprogram(), OldSubprogram);
 598       EXPECT_EQ(NewFunc->getSubprogram(), NewSubprogram);
 599     }
 600
 601     ++OldIter;
 602     ++NewIter;
 603   }
 604   EXPECT_EQ(OldEnd, OldIter);
 605   EXPECT_EQ(NewEnd, NewIter);
 606 }
 607
 608 // Test that the arguments for debug intrinsics in the new function were
 609 // properly cloned
 610 TEST_F(CloneFunc, DebugIntrinsics) {
 611   EXPECT_FALSE(verifyModule(*M));
 612
 613   inst_iterator OldIter = inst_begin(OldFunc);
 614   inst_iterator OldEnd = inst_end(OldFunc);
 615   inst_iterator NewIter = inst_begin(NewFunc);
 616   inst_iterator NewEnd = inst_end(NewFunc);
 617   while (OldIter != OldEnd && NewIter != NewEnd) {
 618     Instruction& OldI = *OldIter;
 619     Instruction& NewI = *NewIter;
 620     if (DbgDeclareInst* OldIntrin = dyn_cast<DbgDeclareInst>(&OldI)) {
 621       DbgDeclareInst* NewIntrin = dyn_cast<DbgDeclareInst>(&NewI);
 622       EXPECT_TRUE(NewIntrin);
 623
 624       // Old address must belong to the old function
 625       EXPECT_EQ(OldFunc, cast<AllocaInst>(OldIntrin->getAddress())->
 626                          getParent()->getParent());
 627       // New address must belong to the new function
 628       EXPECT_EQ(NewFunc, cast<AllocaInst>(NewIntrin->getAddress())->
 629                          getParent()->getParent());
 630
 631       if (OldIntrin->getDebugLoc()->getInlinedAt()) {
 632         // Inlined variable should refer to the same DILocalVariable as in the
 633         // Old Function
 634         EXPECT_EQ(OldIntrin->getVariable(), NewIntrin->getVariable());
 635       } else {
 636         // Old variable must belong to the old function.
 637         EXPECT_EQ(OldFunc->getSubprogram(),
 638                   cast<DISubprogram>(OldIntrin->getVariable()->getScope()));
 639         // New variable must belong to the new function.
 640         EXPECT_EQ(NewFunc->getSubprogram(),
 641                   cast<DISubprogram>(NewIntrin->getVariable()->getScope()));
 642       }
 643     } else if (DbgValueInst* OldIntrin = dyn_cast<DbgValueInst>(&OldI)) {
 644       DbgValueInst* NewIntrin = dyn_cast<DbgValueInst>(&NewI);
 645       EXPECT_TRUE(NewIntrin);
 646
 647       if (!OldIntrin->getDebugLoc()->getInlinedAt()) {
 648         // Old variable must belong to the old function.
 649         EXPECT_EQ(OldFunc->getSubprogram(),
 650                   cast<DISubprogram>(OldIntrin->getVariable()->getScope()));
 651         // New variable must belong to the new function.
 652         EXPECT_EQ(NewFunc->getSubprogram(),
 653                   cast<DISubprogram>(NewIntrin->getVariable()->getScope()));
 654       }
 655     }
 656
 657     ++OldIter;
 658     ++NewIter;
 659   }
 660 }
 661
 662 static int GetDICompileUnitCount(const Module& M) {
 663   if (const auto* LLVM_DBG_CU = M.getNamedMetadata("llvm.dbg.cu")) {
 664     return LLVM_DBG_CU->getNumOperands();
 665   }
 666   return 0;
 667 }
 668
 669 static bool haveCompileUnitsInCommon(const Module &LHS, const Module &RHS) {
 670   const NamedMDNode *LHSCUs = LHS.getNamedMetadata("llvm.dbg.cu");
 671   if (!LHSCUs)
 672     return false;
 673
 674   const NamedMDNode *RHSCUs = RHS.getNamedMetadata("llvm.dbg.cu");
 675   if (!RHSCUs)
 676     return false;
 677
 678   SmallPtrSet<const MDNode *, 8> Found;
 679   for (int I = 0, E = LHSCUs->getNumOperands(); I != E; ++I)
 680     if (const MDNode *N = LHSCUs->getOperand(I))
 681       Found.insert(N);
 682
 683   for (int I = 0, E = RHSCUs->getNumOperands(); I != E; ++I)
 684     if (const MDNode *N = RHSCUs->getOperand(I))
 685       if (Found.count(N))
 686         return true;
 687
 688   return false;
 689 }
 690
 691 TEST(CloneFunction, CloneEmptyFunction) {
 692   StringRef ImplAssembly = R"(
 693     define void @foo() {
 694       ret void
 695     }
 696     declare void @bar()
 697   )";
 698
 699   LLVMContext Context;
 700   SMDiagnostic Error;
 701
 702   auto ImplModule = parseAssemblyString(ImplAssembly, Error, Context);
 703   EXPECT_TRUE(ImplModule != nullptr);
 704   auto *ImplFunction = ImplModule->getFunction("foo");
 705   EXPECT_TRUE(ImplFunction != nullptr);
 706   auto *DeclFunction = ImplModule->getFunction("bar");
 707   EXPECT_TRUE(DeclFunction != nullptr);
 708
 709   ValueToValueMapTy VMap;
 710   SmallVector<ReturnInst *, 8> Returns;
 711   ClonedCodeInfo CCI;
 712   CloneFunctionInto(ImplFunction, DeclFunction, VMap,
 713                     CloneFunctionChangeType::GlobalChanges, Returns, "", &CCI);
 714
 715   EXPECT_FALSE(verifyModule(*ImplModule, &errs()));
 716   EXPECT_FALSE(CCI.ContainsCalls);
 717   EXPECT_FALSE(CCI.ContainsDynamicAllocas);
 718 }
 719
 720 TEST(CloneFunction, CloneFunctionWithInalloca) {
 721   StringRef ImplAssembly = R"(
 722     declare void @a(i32* inalloca(i32))
 723     define void @foo() {
 724       %a = alloca inalloca i32
 725       call void @a(i32* inalloca(i32) %a)
 726       ret void
 727     }
 728     declare void @bar()
 729   )";
 730
 731   LLVMContext Context;
 732   SMDiagnostic Error;
 733
 734   auto ImplModule = parseAssemblyString(ImplAssembly, Error, Context);
 735   EXPECT_TRUE(ImplModule != nullptr);
 736   auto *ImplFunction = ImplModule->getFunction("foo");
 737   EXPECT_TRUE(ImplFunction != nullptr);
 738   auto *DeclFunction = ImplModule->getFunction("bar");
 739   EXPECT_TRUE(DeclFunction != nullptr);
 740
 741   ValueToValueMapTy VMap;
 742   SmallVector<ReturnInst *, 8> Returns;
 743   ClonedCodeInfo CCI;
 744   CloneFunctionInto(DeclFunction, ImplFunction, VMap,
 745                     CloneFunctionChangeType::GlobalChanges, Returns, "", &CCI);
 746
 747   EXPECT_FALSE(verifyModule(*ImplModule, &errs()));
 748   EXPECT_TRUE(CCI.ContainsCalls);
 749   EXPECT_TRUE(CCI.ContainsDynamicAllocas);
 750 }
 751
 752 TEST(CloneFunction, CloneFunctionWithSubprograms) {
 753   // Tests that the debug info is duplicated correctly when a DISubprogram
 754   // happens to be one of the operands of the DISubprogram that is being cloned.
 755   // In general, operands of "test" that are distinct should be duplicated,
 756   // but in this case "my_operator" should not be duplicated. If it is
 757   // duplicated, the metadata in the llvm.dbg.declare could end up with
 758   // different duplicates.
 759   StringRef ImplAssembly = R"(
 760     declare void @llvm.dbg.declare(metadata, metadata, metadata)
 761
 762     define void @test() !dbg !5 {
 763       call void @llvm.dbg.declare(metadata i8* undef, metadata !4, metadata !DIExpression()), !dbg !6
 764       ret void
 765     }
 766
 767     declare void @cloned()
 768
 769     !llvm.dbg.cu = !{!0}
 770     !llvm.module.flags = !{!2}
 771     !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1)
 772     !1 = !DIFile(filename: "test.cpp",  directory: "")
 773     !2 = !{i32 1, !"Debug Info Version", i32 3}
 774     !3 = distinct !DISubprogram(name: "my_operator", scope: !1, unit: !0, retainedNodes: !{!4})
 775     !4 = !DILocalVariable(name: "awaitables", scope: !3)
 776     !5 = distinct !DISubprogram(name: "test", scope: !3, unit: !0)
 777     !6 = !DILocation(line: 55, column: 15, scope: !3, inlinedAt: !7)
 778     !7 = distinct !DILocation(line: 73, column: 14, scope: !5)
 779   )";
 780
 781   LLVMContext Context;
 782   SMDiagnostic Error;
 783
 784   auto ImplModule = parseAssemblyString(ImplAssembly, Error, Context);
 785   EXPECT_TRUE(ImplModule != nullptr);
 786   auto *OldFunc = ImplModule->getFunction("test");
 787   EXPECT_TRUE(OldFunc != nullptr);
 788   auto *NewFunc = ImplModule->getFunction("cloned");
 789   EXPECT_TRUE(NewFunc != nullptr);
 790
 791   ValueToValueMapTy VMap;
 792   SmallVector<ReturnInst *, 8> Returns;
 793   ClonedCodeInfo CCI;
 794   CloneFunctionInto(NewFunc, OldFunc, VMap,
 795                     CloneFunctionChangeType::GlobalChanges, Returns, "", &CCI);
 796
 797   // This fails if the scopes in the llvm.dbg.declare variable and location
 798   // aren't the same.
 799   EXPECT_FALSE(verifyModule(*ImplModule, &errs()));
 800 }
 801
 802 TEST(CloneFunction, CloneFunctionWithInlinedSubprograms) {
 803   StringRef ImplAssembly = R"(
 804     declare void @llvm.dbg.declare(metadata, metadata, metadata)
 805
 806     define void @test() !dbg !3 {
 807       call void @llvm.dbg.declare(metadata i8* undef, metadata !5, metadata !DIExpression()), !dbg !7
 808       ret void
 809     }
 810
 811     declare void @cloned()
 812
 813     !llvm.dbg.cu = !{!0}
 814     !llvm.module.flags = !{!2}
 815     !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1)
 816     !1 = !DIFile(filename: "test.cpp",  directory: "")
 817     !2 = !{i32 1, !"Debug Info Version", i32 3}
 818     !3 = distinct !DISubprogram(name: "test", scope: !0, unit: !0)
 819     !4 = distinct !DISubprogram(name: "inlined", scope: !0, unit: !0, retainedNodes: !{!5})
 820     !5 = !DILocalVariable(name: "awaitables", scope: !4)
 821     !6 = distinct !DILexicalBlock(scope: !4, file: !1, line: 1)
 822     !7 = !DILocation(line: 1, scope: !6, inlinedAt: !8)
 823     !8 = !DILocation(line: 10, scope: !3)
 824   )";
 825
 826   LLVMContext Context;
 827   SMDiagnostic Error;
 828
 829   auto ImplModule = parseAssemblyString(ImplAssembly, Error, Context);
 830   EXPECT_TRUE(ImplModule != nullptr);
 831   auto *Func = ImplModule->getFunction("test");
 832   EXPECT_TRUE(Func != nullptr);
 833   auto *ClonedFunc = ImplModule->getFunction("cloned");
 834   EXPECT_TRUE(ClonedFunc != nullptr);
 835
 836   ValueToValueMapTy VMap;
 837   SmallVector<ReturnInst *, 8> Returns;
 838   ClonedCodeInfo CCI;
 839   CloneFunctionInto(ClonedFunc, Func, VMap,
 840                     CloneFunctionChangeType::GlobalChanges, Returns, "", &CCI);
 841
 842   EXPECT_FALSE(verifyModule(*ImplModule, &errs()));
 843
 844   // Check that DILexicalBlock of inlined function was not cloned.
 845   auto DbgDeclareI = Func->begin()->begin();
 846   auto ClonedDbgDeclareI = ClonedFunc->begin()->begin();
 847   const DebugLoc &DbgLoc = DbgDeclareI->getDebugLoc();
 848   const DebugLoc &ClonedDbgLoc = ClonedDbgDeclareI->getDebugLoc();
 849   EXPECT_NE(DbgLoc.get(), ClonedDbgLoc.get());
 850   EXPECT_EQ(cast<DILexicalBlock>(DbgLoc.getScope()),
 851             cast<DILexicalBlock>(ClonedDbgLoc.getScope()));
 852 }
 853
 854 TEST(CloneFunction, CloneFunctionToDifferentModule) {
 855   StringRef ImplAssembly = R"(
 856     define void @foo() {
 857       ret void, !dbg !5
 858     }
 859
 860     !llvm.module.flags = !{!0}
 861     !llvm.dbg.cu = !{!2, !6}
 862     !0 = !{i32 1, !"Debug Info Version", i32 3}
 863     !1 = distinct !DISubprogram(unit: !2)
 864     !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3)
 865     !3 = !DIFile(filename: "foo.c", directory: "/tmp")
 866     !4 = distinct !DISubprogram(unit: !2)
 867     !5 = !DILocation(line: 4, scope: !1)
 868     !6 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3)
 869   )";
 870   StringRef DeclAssembly = R"(
 871     declare void @foo()
 872   )";
 873
 874   LLVMContext Context;
 875   SMDiagnostic Error;
 876
 877   auto ImplModule = parseAssemblyString(ImplAssembly, Error, Context);
 878   EXPECT_TRUE(ImplModule != nullptr);
 879   // DICompileUnits: !2, !6. Only !2 is reachable from @foo().
 880   EXPECT_TRUE(GetDICompileUnitCount(*ImplModule) == 2);
 881   auto* ImplFunction = ImplModule->getFunction("foo");
 882   EXPECT_TRUE(ImplFunction != nullptr);
 883
 884   auto DeclModule = parseAssemblyString(DeclAssembly, Error, Context);
 885   EXPECT_TRUE(DeclModule != nullptr);
 886   // No DICompileUnits defined here.
 887   EXPECT_TRUE(GetDICompileUnitCount(*DeclModule) == 0);
 888   auto* DeclFunction = DeclModule->getFunction("foo");
 889   EXPECT_TRUE(DeclFunction != nullptr);
 890
 891   ValueToValueMapTy VMap;
 892   VMap[ImplFunction] = DeclFunction;
 893   // No args to map
 894   SmallVector<ReturnInst*, 8> Returns;
 895   CloneFunctionInto(DeclFunction, ImplFunction, VMap,
 896                     CloneFunctionChangeType::DifferentModule, Returns);
 897
 898   EXPECT_FALSE(verifyModule(*ImplModule, &errs()));
 899   EXPECT_FALSE(verifyModule(*DeclModule, &errs()));
 900   // DICompileUnit !2 shall be cloned into DeclModule.
 901   EXPECT_TRUE(GetDICompileUnitCount(*DeclModule) == 1);
 902   EXPECT_FALSE(haveCompileUnitsInCommon(*ImplModule, *DeclModule));
 903 }
 904
 905 class CloneModule : public ::testing::Test {
 906 protected:
 907   void SetUp() override {
 908     SetupModule();
 909     CreateOldModule();
 910     CreateNewModule();
 911   }
 912
 913   void SetupModule() { OldM = new Module("", C); }
 914
 915   void CreateOldModule() {
 916     auto *CD = OldM->getOrInsertComdat("comdat");
 917     CD->setSelectionKind(Comdat::ExactMatch);
 918
 919     auto GV = new GlobalVariable(
 920         *OldM, Type::getInt32Ty(C), false, GlobalValue::ExternalLinkage,
 921         ConstantInt::get(Type::getInt32Ty(C), 1), "gv");
 922     GV->addMetadata(LLVMContext::MD_type, *MDNode::get(C, {}));
 923     GV->setComdat(CD);
 924
 925     {
 926       // Add an empty compile unit first that isn't otherwise referenced, to
 927       // confirm that compile units get cloned in the correct order.
 928       DIBuilder EmptyBuilder(*OldM);
 929       auto *File = EmptyBuilder.createFile("empty.c", "/file/dir/");
 930       (void)EmptyBuilder.createCompileUnit(dwarf::DW_LANG_C99, File,
 931                                            "EmptyUnit", false, "", 0);
 932       EmptyBuilder.finalize();
 933     }
 934
 935     DIBuilder DBuilder(*OldM);
 936     IRBuilder<> IBuilder(C);
 937
 938     auto *FuncType = FunctionType::get(Type::getVoidTy(C), false);
 939     auto *PersFn = Function::Create(FuncType, GlobalValue::ExternalLinkage,
 940                                     "persfn", OldM);
 941     auto *F =
 942         Function::Create(FuncType, GlobalValue::PrivateLinkage, "f", OldM);
 943     F->setPersonalityFn(PersFn);
 944     F->setComdat(CD);
 945
 946     // Create debug info
 947     auto *File = DBuilder.createFile("filename.c", "/file/dir/");
 948     DITypeRefArray ParamTypes = DBuilder.getOrCreateTypeArray(None);
 949     DISubroutineType *DFuncType = DBuilder.createSubroutineType(ParamTypes);
 950     auto *CU = DBuilder.createCompileUnit(dwarf::DW_LANG_C99,
 951                                           DBuilder.createFile("filename.c",
 952                                                               "/file/dir"),
 953                                           "CloneModule", false, "", 0);
 954     // Function DI
 955     auto *Subprogram = DBuilder.createFunction(
 956         CU, "f", "f", File, 4, DFuncType, 3, DINode::FlagZero,
 957         DISubprogram::SPFlagLocalToUnit | DISubprogram::SPFlagDefinition);
 958     F->setSubprogram(Subprogram);
 959
 960     // Create and assign DIGlobalVariableExpression to gv
 961     auto GVExpression = DBuilder.createGlobalVariableExpression(
 962         Subprogram, "gv", "gv", File, 1, DBuilder.createNullPtrType(), false);
 963     GV->addDebugInfo(GVExpression);
 964
 965     // DIGlobalVariableExpression not attached to any global variable
 966     auto Expr = DBuilder.createExpression(
 967         ArrayRef<uint64_t>{dwarf::DW_OP_constu, 42U, dwarf::DW_OP_stack_value});
 968
 969     DBuilder.createGlobalVariableExpression(
 970         Subprogram, "unattached", "unattached", File, 1,
 971         DBuilder.createNullPtrType(), false, true, Expr);
 972
 973     auto *Entry = BasicBlock::Create(C, "", F);
 974     IBuilder.SetInsertPoint(Entry);
 975     IBuilder.CreateRetVoid();
 976
 977     auto *G =
 978         Function::Create(FuncType, GlobalValue::ExternalLinkage, "g", OldM);
 979     G->addMetadata(LLVMContext::MD_type, *MDNode::get(C, {}));
 980
 981     // Finalize the debug info
 982     DBuilder.finalize();
 983   }
 984
 985   void CreateNewModule() { NewM = llvm::CloneModule(*OldM).release(); }
 986
 987   LLVMContext C;
 988   Module *OldM;
 989   Module *NewM;
 990 };
 991
 992 TEST_F(CloneModule, Verify) {
 993   // Confirm the old module is (still) valid.
 994   EXPECT_FALSE(verifyModule(*OldM, &errs()));
 995
 996   // Check the new module.
 997   EXPECT_FALSE(verifyModule(*NewM, &errs()));
 998 }
 999
1000 TEST_F(CloneModule, OldModuleUnchanged) {
1001   DebugInfoFinder Finder;
1002   Finder.processModule(*OldM);
1003   EXPECT_EQ(1U, Finder.subprogram_count());
1004 }
1005
1006 TEST_F(CloneModule, Subprogram) {
1007   Function *NewF = NewM->getFunction("f");
1008   DISubprogram *SP = NewF->getSubprogram();
1009   EXPECT_TRUE(SP != nullptr);
1010   EXPECT_EQ(SP->getName(), "f");
1011   EXPECT_EQ(SP->getFile()->getFilename(), "filename.c");
1012   EXPECT_EQ(SP->getLine(), (unsigned)4);
1013 }
1014
1015 TEST_F(CloneModule, FunctionDeclarationMetadata) {
1016   Function *NewF = NewM->getFunction("g");
1017   EXPECT_NE(nullptr, NewF->getMetadata(LLVMContext::MD_type));
1018 }
1019
1020 TEST_F(CloneModule, GlobalMetadata) {
1021   GlobalVariable *NewGV = NewM->getGlobalVariable("gv");
1022   EXPECT_NE(nullptr, NewGV->getMetadata(LLVMContext::MD_type));
1023 }
1024
1025 TEST_F(CloneModule, GlobalDebugInfo) {
1026   GlobalVariable *NewGV = NewM->getGlobalVariable("gv");
1027   EXPECT_TRUE(NewGV != nullptr);
1028
1029   // Find debug info expression assigned to global
1030   SmallVector<DIGlobalVariableExpression *, 1> GVs;
1031   NewGV->getDebugInfo(GVs);
1032   EXPECT_EQ(GVs.size(), 1U);
1033
1034   DIGlobalVariableExpression *GVExpr = GVs[0];
1035   DIGlobalVariable *GV = GVExpr->getVariable();
1036   EXPECT_TRUE(GV != nullptr);
1037
1038   EXPECT_EQ(GV->getName(), "gv");
1039   EXPECT_EQ(GV->getLine(), 1U);
1040
1041   // Assert that the scope of the debug info attached to
1042   // global variable matches the cloned function.
1043   DISubprogram *SP = NewM->getFunction("f")->getSubprogram();
1044   EXPECT_TRUE(SP != nullptr);
1045   EXPECT_EQ(GV->getScope(), SP);
1046 }
1047
1048 TEST_F(CloneModule, CompileUnit) {
1049   // Find DICompileUnit listed in llvm.dbg.cu
1050   auto *NMD = NewM->getNamedMetadata("llvm.dbg.cu");
1051   EXPECT_TRUE(NMD != nullptr);
1052   EXPECT_EQ(NMD->getNumOperands(), 2U);
1053   EXPECT_FALSE(haveCompileUnitsInCommon(*OldM, *NewM));
1054
1055   // Check that the empty CU is first, even though it's not referenced except
1056   // from named metadata.
1057   DICompileUnit *EmptyCU = dyn_cast<llvm::DICompileUnit>(NMD->getOperand(0));
1058   EXPECT_TRUE(EmptyCU != nullptr);
1059   EXPECT_EQ("EmptyUnit", EmptyCU->getProducer());
1060
1061   // Get the interesting CU.
1062   DICompileUnit *CU = dyn_cast<llvm::DICompileUnit>(NMD->getOperand(1));
1063   EXPECT_TRUE(CU != nullptr);
1064   EXPECT_EQ("CloneModule", CU->getProducer());
1065
1066   // Assert this CU is consistent with the cloned function debug info
1067   DISubprogram *SP = NewM->getFunction("f")->getSubprogram();
1068   EXPECT_TRUE(SP != nullptr);
1069   EXPECT_EQ(SP->getUnit(), CU);
1070
1071   // Check globals listed in CU have the correct scope
1072   DIGlobalVariableExpressionArray GlobalArray = CU->getGlobalVariables();
1073   EXPECT_EQ(GlobalArray.size(), 2U);
1074   for (DIGlobalVariableExpression *GVExpr : GlobalArray) {
1075     DIGlobalVariable *GV = GVExpr->getVariable();
1076     EXPECT_EQ(GV->getScope(), SP);
1077   }
1078 }
1079
1080 TEST_F(CloneModule, Comdat) {
1081   GlobalVariable *NewGV = NewM->getGlobalVariable("gv");
1082   auto *CD = NewGV->getComdat();
1083   ASSERT_NE(nullptr, CD);
1084   EXPECT_EQ("comdat", CD->getName());
1085   EXPECT_EQ(Comdat::ExactMatch, CD->getSelectionKind());
1086
1087   Function *NewF = NewM->getFunction("f");
1088   EXPECT_EQ(CD, NewF->getComdat());
1089 }
1090 }