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 DIFile File = DBuilder.createFile("filename.c", "/file/dir/");
232 DITypeArray ParamTypes = DBuilder.getOrCreateTypeArray(None);
233 DICompositeType FuncType = DBuilder.createSubroutineType(File, ParamTypes);
234 DICompileUnit CU = DBuilder.createCompileUnit(dwarf::DW_LANG_C99,
235 "filename.c", "/file/dir", "CloneFunc", false, "", 0);
237 DISubprogram Subprogram = DBuilder.createFunction(CU, "f", "f", File, 4,
238 FuncType, true, true, 3, 0, false, OldFunc);
241 BasicBlock* Entry = BasicBlock::Create(C, "", OldFunc);
242 IBuilder.SetInsertPoint(Entry);
243 DebugLoc Loc = DebugLoc::get(3, 2, Subprogram);
244 IBuilder.SetCurrentDebugLocation(Loc);
245 AllocaInst* Alloca = IBuilder.CreateAlloca(IntegerType::getInt32Ty(C));
246 IBuilder.SetCurrentDebugLocation(DebugLoc::get(4, 2, Subprogram));
247 Value* AllocaContent = IBuilder.getInt32(1);
248 Instruction* Store = IBuilder.CreateStore(AllocaContent, Alloca);
249 IBuilder.SetCurrentDebugLocation(DebugLoc::get(5, 2, Subprogram));
250 Instruction* Terminator = IBuilder.CreateRetVoid();
252 // Create a local variable around the alloca
253 DIType IntType = DBuilder.createBasicType("int", 32, 0,
254 dwarf::DW_ATE_signed);
255 DIExpression E = DBuilder.createExpression();
256 DIVariable Variable = DBuilder.createLocalVariable(
257 dwarf::DW_TAG_auto_variable, Subprogram, "x", File, 5, IntType, true);
258 auto *DL = MDLocation::get(Subprogram->getContext(), 5, 0, Subprogram);
259 DBuilder.insertDeclare(Alloca, Variable, E, DL, Store);
260 DBuilder.insertDbgValueIntrinsic(AllocaContent, 0, Variable, E, DL,
262 // Finalize the debug info
266 // Create another, empty, compile unit
267 DIBuilder DBuilder2(*M);
268 DBuilder2.createCompileUnit(dwarf::DW_LANG_C99,
269 "extra.c", "/file/dir", "CloneFunc", false, "", 0);
270 DBuilder2.finalize();
273 void CreateNewFunc() {
274 ValueToValueMapTy VMap;
275 NewFunc = CloneFunction(OldFunc, VMap, true, nullptr);
276 M->getFunctionList().push_back(NewFunc);
280 Finder = new DebugInfoFinder();
281 Finder->processModule(*M);
288 DebugInfoFinder* Finder;
291 // Test that a new, distinct function was created.
292 TEST_F(CloneFunc, NewFunctionCreated) {
293 EXPECT_NE(OldFunc, NewFunc);
296 // Test that a new subprogram entry was added and is pointing to the new
297 // function, while the original subprogram still points to the old one.
298 TEST_F(CloneFunc, Subprogram) {
299 EXPECT_FALSE(verifyModule(*M));
301 unsigned SubprogramCount = Finder->subprogram_count();
302 EXPECT_EQ(2U, SubprogramCount);
304 auto Iter = Finder->subprograms().begin();
305 DISubprogram Sub1 = cast<MDSubprogram>(*Iter);
307 DISubprogram Sub2 = cast<MDSubprogram>(*Iter);
310 (Sub1->getFunction() == OldFunc && Sub2->getFunction() == NewFunc) ||
311 (Sub1->getFunction() == NewFunc && Sub2->getFunction() == OldFunc));
314 // Test that the new subprogram entry was not added to the CU which doesn't
315 // contain the old subprogram entry.
316 TEST_F(CloneFunc, SubprogramInRightCU) {
317 EXPECT_FALSE(verifyModule(*M));
319 EXPECT_EQ(2U, Finder->compile_unit_count());
321 auto Iter = Finder->compile_units().begin();
322 DICompileUnit CU1 = cast<MDCompileUnit>(*Iter);
324 DICompileUnit CU2 = cast<MDCompileUnit>(*Iter);
325 EXPECT_TRUE(CU1->getSubprograms().size() == 0 ||
326 CU2->getSubprograms().size() == 0);
329 // Test that instructions in the old function still belong to it in the
330 // metadata, while instruction in the new function belong to the new one.
331 TEST_F(CloneFunc, InstructionOwnership) {
332 EXPECT_FALSE(verifyModule(*M));
334 inst_iterator OldIter = inst_begin(OldFunc);
335 inst_iterator OldEnd = inst_end(OldFunc);
336 inst_iterator NewIter = inst_begin(NewFunc);
337 inst_iterator NewEnd = inst_end(NewFunc);
338 while (OldIter != OldEnd && NewIter != NewEnd) {
339 Instruction& OldI = *OldIter;
340 Instruction& NewI = *NewIter;
341 EXPECT_NE(&OldI, &NewI);
343 EXPECT_EQ(OldI.hasMetadata(), NewI.hasMetadata());
344 if (OldI.hasMetadata()) {
345 const DebugLoc& OldDL = OldI.getDebugLoc();
346 const DebugLoc& NewDL = NewI.getDebugLoc();
348 // Verify that the debug location data is the same
349 EXPECT_EQ(OldDL.getLine(), NewDL.getLine());
350 EXPECT_EQ(OldDL.getCol(), NewDL.getCol());
352 // But that they belong to different functions
353 auto *OldSubprogram = cast<MDSubprogram>(OldDL.getScope());
354 auto *NewSubprogram = cast<MDSubprogram>(NewDL.getScope());
355 EXPECT_EQ(OldFunc, OldSubprogram->getFunction());
356 EXPECT_EQ(NewFunc, NewSubprogram->getFunction());
362 EXPECT_EQ(OldEnd, OldIter);
363 EXPECT_EQ(NewEnd, NewIter);
366 // Test that the arguments for debug intrinsics in the new function were
368 TEST_F(CloneFunc, DebugIntrinsics) {
369 EXPECT_FALSE(verifyModule(*M));
371 inst_iterator OldIter = inst_begin(OldFunc);
372 inst_iterator OldEnd = inst_end(OldFunc);
373 inst_iterator NewIter = inst_begin(NewFunc);
374 inst_iterator NewEnd = inst_end(NewFunc);
375 while (OldIter != OldEnd && NewIter != NewEnd) {
376 Instruction& OldI = *OldIter;
377 Instruction& NewI = *NewIter;
378 if (DbgDeclareInst* OldIntrin = dyn_cast<DbgDeclareInst>(&OldI)) {
379 DbgDeclareInst* NewIntrin = dyn_cast<DbgDeclareInst>(&NewI);
380 EXPECT_TRUE(NewIntrin);
382 // Old address must belong to the old function
383 EXPECT_EQ(OldFunc, cast<AllocaInst>(OldIntrin->getAddress())->
384 getParent()->getParent());
385 // New address must belong to the new function
386 EXPECT_EQ(NewFunc, cast<AllocaInst>(NewIntrin->getAddress())->
387 getParent()->getParent());
389 // Old variable must belong to the old function
391 cast<MDSubprogram>(OldIntrin->getVariable()->getScope())
393 // New variable must belong to the New function
395 cast<MDSubprogram>(NewIntrin->getVariable()->getScope())
397 } else if (DbgValueInst* OldIntrin = dyn_cast<DbgValueInst>(&OldI)) {
398 DbgValueInst* NewIntrin = dyn_cast<DbgValueInst>(&NewI);
399 EXPECT_TRUE(NewIntrin);
401 // Old variable must belong to the old function
403 cast<MDSubprogram>(OldIntrin->getVariable()->getScope())
405 // New variable must belong to the New function
407 cast<MDSubprogram>(NewIntrin->getVariable()->getScope())