1 //===- Cloning.cpp - Unit tests for the Cloner ----------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/Transforms/Utils/Cloning.h"
11 #include "llvm/ADT/ArrayRef.h"
12 #include "llvm/ADT/STLExtras.h"
13 #include "llvm/ADT/SmallPtrSet.h"
14 #include "llvm/IR/Argument.h"
15 #include "llvm/IR/Constant.h"
16 #include "llvm/IR/DIBuilder.h"
17 #include "llvm/IR/DebugInfo.h"
18 #include "llvm/IR/Function.h"
19 #include "llvm/IR/IRBuilder.h"
20 #include "llvm/IR/InstIterator.h"
21 #include "llvm/IR/Instructions.h"
22 #include "llvm/IR/IntrinsicInst.h"
23 #include "llvm/IR/LLVMContext.h"
24 #include "llvm/IR/Module.h"
25 #include "llvm/IR/Verifier.h"
26 #include "gtest/gtest.h"
32 class CloneInstruction : public ::testing::Test {
34 void SetUp() override { V = nullptr; }
38 Value *V2 = V1->clone();
45 DeleteContainerPointers(Clones);
48 void TearDown() override {
50 DeleteContainerPointers(Orig);
54 SmallPtrSet<Value *, 4> Orig; // Erase on exit
55 SmallPtrSet<Value *, 4> Clones; // Erase in eraseClones
61 TEST_F(CloneInstruction, OverflowBits) {
62 V = new Argument(Type::getInt32Ty(context));
64 BinaryOperator *Add = BinaryOperator::Create(Instruction::Add, V, V);
65 BinaryOperator *Sub = BinaryOperator::Create(Instruction::Sub, V, V);
66 BinaryOperator *Mul = BinaryOperator::Create(Instruction::Mul, V, V);
68 BinaryOperator *AddClone = this->clone(Add);
69 BinaryOperator *SubClone = this->clone(Sub);
70 BinaryOperator *MulClone = this->clone(Mul);
72 EXPECT_FALSE(AddClone->hasNoUnsignedWrap());
73 EXPECT_FALSE(AddClone->hasNoSignedWrap());
74 EXPECT_FALSE(SubClone->hasNoUnsignedWrap());
75 EXPECT_FALSE(SubClone->hasNoSignedWrap());
76 EXPECT_FALSE(MulClone->hasNoUnsignedWrap());
77 EXPECT_FALSE(MulClone->hasNoSignedWrap());
81 Add->setHasNoUnsignedWrap();
82 Sub->setHasNoUnsignedWrap();
83 Mul->setHasNoUnsignedWrap();
85 AddClone = this->clone(Add);
86 SubClone = this->clone(Sub);
87 MulClone = this->clone(Mul);
89 EXPECT_TRUE(AddClone->hasNoUnsignedWrap());
90 EXPECT_FALSE(AddClone->hasNoSignedWrap());
91 EXPECT_TRUE(SubClone->hasNoUnsignedWrap());
92 EXPECT_FALSE(SubClone->hasNoSignedWrap());
93 EXPECT_TRUE(MulClone->hasNoUnsignedWrap());
94 EXPECT_FALSE(MulClone->hasNoSignedWrap());
98 Add->setHasNoSignedWrap();
99 Sub->setHasNoSignedWrap();
100 Mul->setHasNoSignedWrap();
102 AddClone = this->clone(Add);
103 SubClone = this->clone(Sub);
104 MulClone = this->clone(Mul);
106 EXPECT_TRUE(AddClone->hasNoUnsignedWrap());
107 EXPECT_TRUE(AddClone->hasNoSignedWrap());
108 EXPECT_TRUE(SubClone->hasNoUnsignedWrap());
109 EXPECT_TRUE(SubClone->hasNoSignedWrap());
110 EXPECT_TRUE(MulClone->hasNoUnsignedWrap());
111 EXPECT_TRUE(MulClone->hasNoSignedWrap());
115 Add->setHasNoUnsignedWrap(false);
116 Sub->setHasNoUnsignedWrap(false);
117 Mul->setHasNoUnsignedWrap(false);
119 AddClone = this->clone(Add);
120 SubClone = this->clone(Sub);
121 MulClone = this->clone(Mul);
123 EXPECT_FALSE(AddClone->hasNoUnsignedWrap());
124 EXPECT_TRUE(AddClone->hasNoSignedWrap());
125 EXPECT_FALSE(SubClone->hasNoUnsignedWrap());
126 EXPECT_TRUE(SubClone->hasNoSignedWrap());
127 EXPECT_FALSE(MulClone->hasNoUnsignedWrap());
128 EXPECT_TRUE(MulClone->hasNoSignedWrap());
131 TEST_F(CloneInstruction, Inbounds) {
132 V = new Argument(Type::getInt32PtrTy(context));
134 Constant *Z = Constant::getNullValue(Type::getInt32Ty(context));
135 std::vector<Value *> ops;
137 GetElementPtrInst *GEP =
138 GetElementPtrInst::Create(Type::getInt32Ty(context), V, ops);
139 EXPECT_FALSE(this->clone(GEP)->isInBounds());
141 GEP->setIsInBounds();
142 EXPECT_TRUE(this->clone(GEP)->isInBounds());
145 TEST_F(CloneInstruction, Exact) {
146 V = new Argument(Type::getInt32Ty(context));
148 BinaryOperator *SDiv = BinaryOperator::Create(Instruction::SDiv, V, V);
149 EXPECT_FALSE(this->clone(SDiv)->isExact());
151 SDiv->setIsExact(true);
152 EXPECT_TRUE(this->clone(SDiv)->isExact());
155 TEST_F(CloneInstruction, Attributes) {
156 Type *ArgTy1[] = { Type::getInt32PtrTy(context) };
157 FunctionType *FT1 = FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
159 Function *F1 = Function::Create(FT1, Function::ExternalLinkage);
160 BasicBlock *BB = BasicBlock::Create(context, "", F1);
161 IRBuilder<> Builder(BB);
162 Builder.CreateRetVoid();
164 Function *F2 = Function::Create(FT1, Function::ExternalLinkage);
166 Attribute::AttrKind AK[] = { Attribute::NoCapture };
167 AttributeSet AS = AttributeSet::get(context, 0, AK);
168 Argument *A = F1->arg_begin();
171 SmallVector<ReturnInst*, 4> Returns;
172 ValueToValueMapTy VMap;
173 VMap[A] = UndefValue::get(A->getType());
175 CloneFunctionInto(F2, F1, VMap, false, Returns);
176 EXPECT_FALSE(F2->arg_begin()->hasNoCaptureAttr());
182 TEST_F(CloneInstruction, CallingConvention) {
183 Type *ArgTy1[] = { Type::getInt32PtrTy(context) };
184 FunctionType *FT1 = FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
186 Function *F1 = Function::Create(FT1, Function::ExternalLinkage);
187 F1->setCallingConv(CallingConv::Cold);
188 BasicBlock *BB = BasicBlock::Create(context, "", F1);
189 IRBuilder<> Builder(BB);
190 Builder.CreateRetVoid();
192 Function *F2 = Function::Create(FT1, Function::ExternalLinkage);
194 SmallVector<ReturnInst*, 4> Returns;
195 ValueToValueMapTy VMap;
196 VMap[F1->arg_begin()] = F2->arg_begin();
198 CloneFunctionInto(F2, F1, VMap, false, Returns);
199 EXPECT_EQ(CallingConv::Cold, F2->getCallingConv());
205 class CloneFunc : public ::testing::Test {
207 void SetUp() override {
214 void TearDown() override { delete Finder; }
217 M = new Module("", C);
220 void CreateOldFunc() {
221 FunctionType* FuncType = FunctionType::get(Type::getVoidTy(C), false);
222 OldFunc = Function::Create(FuncType, GlobalValue::PrivateLinkage, "f", M);
223 CreateOldFunctionBodyAndDI();
226 void CreateOldFunctionBodyAndDI() {
227 DIBuilder DBuilder(*M);
228 IRBuilder<> IBuilder(C);
231 auto *File = DBuilder.createFile("filename.c", "/file/dir/");
232 DITypeRefArray ParamTypes = DBuilder.getOrCreateTypeArray(None);
233 DISubroutineType *FuncType =
234 DBuilder.createSubroutineType(File, ParamTypes);
236 DBuilder.createCompileUnit(dwarf::DW_LANG_C99, "filename.c",
237 "/file/dir", "CloneFunc", false, "", 0);
239 auto *Subprogram = DBuilder.createFunction(
240 CU, "f", "f", File, 4, FuncType, true, true, 3, 0, false, OldFunc);
243 BasicBlock* Entry = BasicBlock::Create(C, "", OldFunc);
244 IBuilder.SetInsertPoint(Entry);
245 DebugLoc Loc = DebugLoc::get(3, 2, Subprogram);
246 IBuilder.SetCurrentDebugLocation(Loc);
247 AllocaInst* Alloca = IBuilder.CreateAlloca(IntegerType::getInt32Ty(C));
248 IBuilder.SetCurrentDebugLocation(DebugLoc::get(4, 2, Subprogram));
249 Value* AllocaContent = IBuilder.getInt32(1);
250 Instruction* Store = IBuilder.CreateStore(AllocaContent, Alloca);
251 IBuilder.SetCurrentDebugLocation(DebugLoc::get(5, 2, Subprogram));
252 Instruction* Terminator = IBuilder.CreateRetVoid();
254 // Create a local variable around the alloca
256 DBuilder.createBasicType("int", 32, 0, dwarf::DW_ATE_signed);
257 auto *E = DBuilder.createExpression();
259 DBuilder.createAutoVariable(Subprogram, "x", File, 5, IntType, true);
260 auto *DL = DILocation::get(Subprogram->getContext(), 5, 0, Subprogram);
261 DBuilder.insertDeclare(Alloca, Variable, E, DL, Store);
262 DBuilder.insertDbgValueIntrinsic(AllocaContent, 0, Variable, E, DL,
264 // Finalize the debug info
268 // Create another, empty, compile unit
269 DIBuilder DBuilder2(*M);
270 DBuilder2.createCompileUnit(dwarf::DW_LANG_C99,
271 "extra.c", "/file/dir", "CloneFunc", false, "", 0);
272 DBuilder2.finalize();
275 void CreateNewFunc() {
276 ValueToValueMapTy VMap;
277 NewFunc = CloneFunction(OldFunc, VMap, true, nullptr);
278 M->getFunctionList().push_back(NewFunc);
282 Finder = new DebugInfoFinder();
283 Finder->processModule(*M);
290 DebugInfoFinder* Finder;
293 // Test that a new, distinct function was created.
294 TEST_F(CloneFunc, NewFunctionCreated) {
295 EXPECT_NE(OldFunc, NewFunc);
298 // Test that a new subprogram entry was added and is pointing to the new
299 // function, while the original subprogram still points to the old one.
300 TEST_F(CloneFunc, Subprogram) {
301 EXPECT_FALSE(verifyModule(*M));
303 unsigned SubprogramCount = Finder->subprogram_count();
304 EXPECT_EQ(2U, SubprogramCount);
306 auto Iter = Finder->subprograms().begin();
307 auto *Sub1 = cast<DISubprogram>(*Iter);
309 auto *Sub2 = cast<DISubprogram>(*Iter);
312 (Sub1->getFunction() == OldFunc && Sub2->getFunction() == NewFunc) ||
313 (Sub1->getFunction() == NewFunc && Sub2->getFunction() == OldFunc));
316 // Test that the new subprogram entry was not added to the CU which doesn't
317 // contain the old subprogram entry.
318 TEST_F(CloneFunc, SubprogramInRightCU) {
319 EXPECT_FALSE(verifyModule(*M));
321 EXPECT_EQ(2U, Finder->compile_unit_count());
323 auto Iter = Finder->compile_units().begin();
324 auto *CU1 = cast<DICompileUnit>(*Iter);
326 auto *CU2 = cast<DICompileUnit>(*Iter);
327 EXPECT_TRUE(CU1->getSubprograms().size() == 0 ||
328 CU2->getSubprograms().size() == 0);
331 // Test that instructions in the old function still belong to it in the
332 // metadata, while instruction in the new function belong to the new one.
333 TEST_F(CloneFunc, InstructionOwnership) {
334 EXPECT_FALSE(verifyModule(*M));
336 inst_iterator OldIter = inst_begin(OldFunc);
337 inst_iterator OldEnd = inst_end(OldFunc);
338 inst_iterator NewIter = inst_begin(NewFunc);
339 inst_iterator NewEnd = inst_end(NewFunc);
340 while (OldIter != OldEnd && NewIter != NewEnd) {
341 Instruction& OldI = *OldIter;
342 Instruction& NewI = *NewIter;
343 EXPECT_NE(&OldI, &NewI);
345 EXPECT_EQ(OldI.hasMetadata(), NewI.hasMetadata());
346 if (OldI.hasMetadata()) {
347 const DebugLoc& OldDL = OldI.getDebugLoc();
348 const DebugLoc& NewDL = NewI.getDebugLoc();
350 // Verify that the debug location data is the same
351 EXPECT_EQ(OldDL.getLine(), NewDL.getLine());
352 EXPECT_EQ(OldDL.getCol(), NewDL.getCol());
354 // But that they belong to different functions
355 auto *OldSubprogram = cast<DISubprogram>(OldDL.getScope());
356 auto *NewSubprogram = cast<DISubprogram>(NewDL.getScope());
357 EXPECT_EQ(OldFunc, OldSubprogram->getFunction());
358 EXPECT_EQ(NewFunc, NewSubprogram->getFunction());
364 EXPECT_EQ(OldEnd, OldIter);
365 EXPECT_EQ(NewEnd, NewIter);
368 // Test that the arguments for debug intrinsics in the new function were
370 TEST_F(CloneFunc, DebugIntrinsics) {
371 EXPECT_FALSE(verifyModule(*M));
373 inst_iterator OldIter = inst_begin(OldFunc);
374 inst_iterator OldEnd = inst_end(OldFunc);
375 inst_iterator NewIter = inst_begin(NewFunc);
376 inst_iterator NewEnd = inst_end(NewFunc);
377 while (OldIter != OldEnd && NewIter != NewEnd) {
378 Instruction& OldI = *OldIter;
379 Instruction& NewI = *NewIter;
380 if (DbgDeclareInst* OldIntrin = dyn_cast<DbgDeclareInst>(&OldI)) {
381 DbgDeclareInst* NewIntrin = dyn_cast<DbgDeclareInst>(&NewI);
382 EXPECT_TRUE(NewIntrin);
384 // Old address must belong to the old function
385 EXPECT_EQ(OldFunc, cast<AllocaInst>(OldIntrin->getAddress())->
386 getParent()->getParent());
387 // New address must belong to the new function
388 EXPECT_EQ(NewFunc, cast<AllocaInst>(NewIntrin->getAddress())->
389 getParent()->getParent());
391 // Old variable must belong to the old function
393 cast<DISubprogram>(OldIntrin->getVariable()->getScope())
395 // New variable must belong to the New function
397 cast<DISubprogram>(NewIntrin->getVariable()->getScope())
399 } else if (DbgValueInst* OldIntrin = dyn_cast<DbgValueInst>(&OldI)) {
400 DbgValueInst* NewIntrin = dyn_cast<DbgValueInst>(&NewI);
401 EXPECT_TRUE(NewIntrin);
403 // Old variable must belong to the old function
405 cast<DISubprogram>(OldIntrin->getVariable()->getScope())
407 // New variable must belong to the New function
409 cast<DISubprogram>(NewIntrin->getVariable()->getScope())
418 class CloneModule : public ::testing::Test {
420 void SetUp() override {
426 void SetupModule() { OldM = new Module("", C); }
428 void CreateOldModule() {
429 IRBuilder<> IBuilder(C);
431 auto *FuncType = FunctionType::get(Type::getVoidTy(C), false);
432 auto *PersFn = Function::Create(FuncType, GlobalValue::ExternalLinkage,
435 Function::Create(FuncType, GlobalValue::PrivateLinkage, "f", OldM);
436 F->setPersonalityFn(PersFn);
437 auto *Entry = BasicBlock::Create(C, "", F);
438 IBuilder.SetInsertPoint(Entry);
439 IBuilder.CreateRetVoid();
442 void CreateNewModule() { NewM = llvm::CloneModule(OldM); }
449 TEST_F(CloneModule, Verify) {
450 EXPECT_FALSE(verifyModule(*NewM));