1 //===- llvm/unittest/IR/InstructionsTest.cpp - Instructions unit tests ----===//
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/IR/Instructions.h"
11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/Analysis/ValueTracking.h"
13 #include "llvm/IR/BasicBlock.h"
14 #include "llvm/IR/Constants.h"
15 #include "llvm/IR/DataLayout.h"
16 #include "llvm/IR/DerivedTypes.h"
17 #include "llvm/IR/Function.h"
18 #include "llvm/IR/IRBuilder.h"
19 #include "llvm/IR/LLVMContext.h"
20 #include "llvm/IR/MDBuilder.h"
21 #include "llvm/IR/Module.h"
22 #include "llvm/IR/Operator.h"
23 #include "gtest/gtest.h"
29 TEST(InstructionsTest
, ReturnInst
) {
33 const ReturnInst
* r0
= ReturnInst::Create(C
);
34 EXPECT_EQ(r0
->getNumOperands(), 0U);
35 EXPECT_EQ(r0
->op_begin(), r0
->op_end());
37 IntegerType
* Int1
= IntegerType::get(C
, 1);
38 Constant
* One
= ConstantInt::get(Int1
, 1, true);
39 const ReturnInst
* r1
= ReturnInst::Create(C
, One
);
40 EXPECT_EQ(1U, r1
->getNumOperands());
41 User::const_op_iterator
b(r1
->op_begin());
42 EXPECT_NE(r1
->op_end(), b
);
44 EXPECT_EQ(One
, r1
->getOperand(0));
46 EXPECT_EQ(r1
->op_end(), b
);
53 // Test fixture that provides a module and a single function within it. Useful
54 // for tests that need to refer to the function in some way.
55 class ModuleWithFunctionTest
: public testing::Test
{
57 ModuleWithFunctionTest() : M(new Module("MyModule", Ctx
)) {
58 FArgTypes
.push_back(Type::getInt8Ty(Ctx
));
59 FArgTypes
.push_back(Type::getInt32Ty(Ctx
));
60 FArgTypes
.push_back(Type::getInt64Ty(Ctx
));
62 FunctionType::get(Type::getVoidTy(Ctx
), FArgTypes
, false);
63 F
= Function::Create(FTy
, Function::ExternalLinkage
, "", M
.get());
67 std::unique_ptr
<Module
> M
;
68 SmallVector
<Type
*, 3> FArgTypes
;
72 TEST_F(ModuleWithFunctionTest
, CallInst
) {
73 Value
*Args
[] = {ConstantInt::get(Type::getInt8Ty(Ctx
), 20),
74 ConstantInt::get(Type::getInt32Ty(Ctx
), 9999),
75 ConstantInt::get(Type::getInt64Ty(Ctx
), 42)};
76 std::unique_ptr
<CallInst
> Call(CallInst::Create(F
, Args
));
78 // Make sure iteration over a call's arguments works as expected.
80 for (Value
*Arg
: Call
->arg_operands()) {
81 EXPECT_EQ(FArgTypes
[Idx
], Arg
->getType());
82 EXPECT_EQ(Call
->getArgOperand(Idx
)->getType(), Arg
->getType());
87 TEST_F(ModuleWithFunctionTest
, InvokeInst
) {
88 BasicBlock
*BB1
= BasicBlock::Create(Ctx
, "", F
);
89 BasicBlock
*BB2
= BasicBlock::Create(Ctx
, "", F
);
91 Value
*Args
[] = {ConstantInt::get(Type::getInt8Ty(Ctx
), 20),
92 ConstantInt::get(Type::getInt32Ty(Ctx
), 9999),
93 ConstantInt::get(Type::getInt64Ty(Ctx
), 42)};
94 std::unique_ptr
<InvokeInst
> Invoke(InvokeInst::Create(F
, BB1
, BB2
, Args
));
96 // Make sure iteration over invoke's arguments works as expected.
98 for (Value
*Arg
: Invoke
->arg_operands()) {
99 EXPECT_EQ(FArgTypes
[Idx
], Arg
->getType());
100 EXPECT_EQ(Invoke
->getArgOperand(Idx
)->getType(), Arg
->getType());
105 TEST(InstructionsTest
, BranchInst
) {
108 // Make a BasicBlocks
109 BasicBlock
* bb0
= BasicBlock::Create(C
);
110 BasicBlock
* bb1
= BasicBlock::Create(C
);
112 // Mandatory BranchInst
113 const BranchInst
* b0
= BranchInst::Create(bb0
);
115 EXPECT_TRUE(b0
->isUnconditional());
116 EXPECT_FALSE(b0
->isConditional());
117 EXPECT_EQ(1U, b0
->getNumSuccessors());
119 // check num operands
120 EXPECT_EQ(1U, b0
->getNumOperands());
122 EXPECT_NE(b0
->op_begin(), b0
->op_end());
123 EXPECT_EQ(b0
->op_end(), std::next(b0
->op_begin()));
125 EXPECT_EQ(b0
->op_end(), std::next(b0
->op_begin()));
127 IntegerType
* Int1
= IntegerType::get(C
, 1);
128 Constant
* One
= ConstantInt::get(Int1
, 1, true);
130 // Conditional BranchInst
131 BranchInst
* b1
= BranchInst::Create(bb0
, bb1
, One
);
133 EXPECT_FALSE(b1
->isUnconditional());
134 EXPECT_TRUE(b1
->isConditional());
135 EXPECT_EQ(2U, b1
->getNumSuccessors());
137 // check num operands
138 EXPECT_EQ(3U, b1
->getNumOperands());
140 User::const_op_iterator
b(b1
->op_begin());
143 EXPECT_NE(b
, b1
->op_end());
145 EXPECT_EQ(One
, b1
->getOperand(0));
146 EXPECT_EQ(One
, b1
->getCondition());
151 EXPECT_EQ(bb1
, b1
->getOperand(1));
152 EXPECT_EQ(bb1
, b1
->getSuccessor(1));
157 EXPECT_EQ(bb0
, b1
->getOperand(2));
158 EXPECT_EQ(bb0
, b1
->getSuccessor(0));
161 EXPECT_EQ(b1
->op_end(), b
);
171 TEST(InstructionsTest
, CastInst
) {
174 Type
*Int8Ty
= Type::getInt8Ty(C
);
175 Type
*Int16Ty
= Type::getInt16Ty(C
);
176 Type
*Int32Ty
= Type::getInt32Ty(C
);
177 Type
*Int64Ty
= Type::getInt64Ty(C
);
178 Type
*V8x8Ty
= VectorType::get(Int8Ty
, 8);
179 Type
*V8x64Ty
= VectorType::get(Int64Ty
, 8);
180 Type
*X86MMXTy
= Type::getX86_MMXTy(C
);
182 Type
*HalfTy
= Type::getHalfTy(C
);
183 Type
*FloatTy
= Type::getFloatTy(C
);
184 Type
*DoubleTy
= Type::getDoubleTy(C
);
186 Type
*V2Int32Ty
= VectorType::get(Int32Ty
, 2);
187 Type
*V2Int64Ty
= VectorType::get(Int64Ty
, 2);
188 Type
*V4Int16Ty
= VectorType::get(Int16Ty
, 4);
190 Type
*Int32PtrTy
= PointerType::get(Int32Ty
, 0);
191 Type
*Int64PtrTy
= PointerType::get(Int64Ty
, 0);
193 Type
*Int32PtrAS1Ty
= PointerType::get(Int32Ty
, 1);
194 Type
*Int64PtrAS1Ty
= PointerType::get(Int64Ty
, 1);
196 Type
*V2Int32PtrAS1Ty
= VectorType::get(Int32PtrAS1Ty
, 2);
197 Type
*V2Int64PtrAS1Ty
= VectorType::get(Int64PtrAS1Ty
, 2);
198 Type
*V4Int32PtrAS1Ty
= VectorType::get(Int32PtrAS1Ty
, 4);
199 Type
*V4Int64PtrAS1Ty
= VectorType::get(Int64PtrAS1Ty
, 4);
201 Type
*V2Int64PtrTy
= VectorType::get(Int64PtrTy
, 2);
202 Type
*V2Int32PtrTy
= VectorType::get(Int32PtrTy
, 2);
203 Type
*V4Int32PtrTy
= VectorType::get(Int32PtrTy
, 4);
205 const Constant
* c8
= Constant::getNullValue(V8x8Ty
);
206 const Constant
* c64
= Constant::getNullValue(V8x64Ty
);
208 const Constant
*v2ptr32
= Constant::getNullValue(V2Int32PtrTy
);
210 EXPECT_TRUE(CastInst::isCastable(V8x8Ty
, X86MMXTy
));
211 EXPECT_TRUE(CastInst::isCastable(X86MMXTy
, V8x8Ty
));
212 EXPECT_FALSE(CastInst::isCastable(Int64Ty
, X86MMXTy
));
213 EXPECT_TRUE(CastInst::isCastable(V8x64Ty
, V8x8Ty
));
214 EXPECT_TRUE(CastInst::isCastable(V8x8Ty
, V8x64Ty
));
215 EXPECT_EQ(CastInst::Trunc
, CastInst::getCastOpcode(c64
, true, V8x8Ty
, true));
216 EXPECT_EQ(CastInst::SExt
, CastInst::getCastOpcode(c8
, true, V8x64Ty
, true));
218 EXPECT_FALSE(CastInst::isBitCastable(V8x8Ty
, X86MMXTy
));
219 EXPECT_FALSE(CastInst::isBitCastable(X86MMXTy
, V8x8Ty
));
220 EXPECT_FALSE(CastInst::isBitCastable(Int64Ty
, X86MMXTy
));
221 EXPECT_FALSE(CastInst::isBitCastable(V8x64Ty
, V8x8Ty
));
222 EXPECT_FALSE(CastInst::isBitCastable(V8x8Ty
, V8x64Ty
));
224 // Check address space casts are rejected since we don't know the sizes here
225 EXPECT_FALSE(CastInst::isBitCastable(Int32PtrTy
, Int32PtrAS1Ty
));
226 EXPECT_FALSE(CastInst::isBitCastable(Int32PtrAS1Ty
, Int32PtrTy
));
227 EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrTy
, V2Int32PtrAS1Ty
));
228 EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrAS1Ty
, V2Int32PtrTy
));
229 EXPECT_TRUE(CastInst::isBitCastable(V2Int32PtrAS1Ty
, V2Int64PtrAS1Ty
));
230 EXPECT_TRUE(CastInst::isCastable(V2Int32PtrAS1Ty
, V2Int32PtrTy
));
231 EXPECT_EQ(CastInst::AddrSpaceCast
, CastInst::getCastOpcode(v2ptr32
, true,
235 // Test mismatched number of elements for pointers
236 EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrAS1Ty
, V4Int64PtrAS1Ty
));
237 EXPECT_FALSE(CastInst::isBitCastable(V4Int64PtrAS1Ty
, V2Int32PtrAS1Ty
));
238 EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrAS1Ty
, V4Int32PtrAS1Ty
));
239 EXPECT_FALSE(CastInst::isBitCastable(Int32PtrTy
, V2Int32PtrTy
));
240 EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrTy
, Int32PtrTy
));
242 EXPECT_TRUE(CastInst::isBitCastable(Int32PtrTy
, Int64PtrTy
));
243 EXPECT_FALSE(CastInst::isBitCastable(DoubleTy
, FloatTy
));
244 EXPECT_FALSE(CastInst::isBitCastable(FloatTy
, DoubleTy
));
245 EXPECT_TRUE(CastInst::isBitCastable(FloatTy
, FloatTy
));
246 EXPECT_TRUE(CastInst::isBitCastable(FloatTy
, FloatTy
));
247 EXPECT_TRUE(CastInst::isBitCastable(FloatTy
, Int32Ty
));
248 EXPECT_TRUE(CastInst::isBitCastable(Int16Ty
, HalfTy
));
249 EXPECT_TRUE(CastInst::isBitCastable(Int32Ty
, FloatTy
));
250 EXPECT_TRUE(CastInst::isBitCastable(V2Int32Ty
, Int64Ty
));
252 EXPECT_TRUE(CastInst::isBitCastable(V2Int32Ty
, V4Int16Ty
));
253 EXPECT_FALSE(CastInst::isBitCastable(Int32Ty
, Int64Ty
));
254 EXPECT_FALSE(CastInst::isBitCastable(Int64Ty
, Int32Ty
));
256 EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrTy
, Int64Ty
));
257 EXPECT_FALSE(CastInst::isBitCastable(Int64Ty
, V2Int32PtrTy
));
258 EXPECT_TRUE(CastInst::isBitCastable(V2Int64PtrTy
, V2Int32PtrTy
));
259 EXPECT_TRUE(CastInst::isBitCastable(V2Int32PtrTy
, V2Int64PtrTy
));
260 EXPECT_FALSE(CastInst::isBitCastable(V2Int32Ty
, V2Int64Ty
));
261 EXPECT_FALSE(CastInst::isBitCastable(V2Int64Ty
, V2Int32Ty
));
264 EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast
,
265 Constant::getNullValue(V4Int32PtrTy
),
267 EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast
,
268 Constant::getNullValue(V2Int32PtrTy
),
271 EXPECT_FALSE(CastInst::castIsValid(Instruction::AddrSpaceCast
,
272 Constant::getNullValue(V4Int32PtrAS1Ty
),
274 EXPECT_FALSE(CastInst::castIsValid(Instruction::AddrSpaceCast
,
275 Constant::getNullValue(V2Int32PtrTy
),
279 // Check that assertion is not hit when creating a cast with a vector of
282 BasicBlock
*BB
= BasicBlock::Create(C
);
283 Constant
*NullV2I32Ptr
= Constant::getNullValue(V2Int32PtrTy
);
284 auto Inst1
= CastInst::CreatePointerCast(NullV2I32Ptr
, V2Int32Ty
, "foo", BB
);
287 auto Inst2
= CastInst::CreatePointerCast(NullV2I32Ptr
, V2Int32Ty
);
290 Inst1
->eraseFromParent();
294 TEST(InstructionsTest
, VectorGep
) {
298 Type
*I8Ty
= IntegerType::get(C
, 8);
299 Type
*I32Ty
= IntegerType::get(C
, 32);
300 PointerType
*Ptri8Ty
= PointerType::get(I8Ty
, 0);
301 PointerType
*Ptri32Ty
= PointerType::get(I32Ty
, 0);
303 VectorType
*V2xi8PTy
= VectorType::get(Ptri8Ty
, 2);
304 VectorType
*V2xi32PTy
= VectorType::get(Ptri32Ty
, 2);
306 // Test different aspects of the vector-of-pointers type
307 // and GEPs which use this type.
308 ConstantInt
*Ci32a
= ConstantInt::get(C
, APInt(32, 1492));
309 ConstantInt
*Ci32b
= ConstantInt::get(C
, APInt(32, 1948));
310 std::vector
<Constant
*> ConstVa(2, Ci32a
);
311 std::vector
<Constant
*> ConstVb(2, Ci32b
);
312 Constant
*C2xi32a
= ConstantVector::get(ConstVa
);
313 Constant
*C2xi32b
= ConstantVector::get(ConstVb
);
315 CastInst
*PtrVecA
= new IntToPtrInst(C2xi32a
, V2xi32PTy
);
316 CastInst
*PtrVecB
= new IntToPtrInst(C2xi32b
, V2xi32PTy
);
318 ICmpInst
*ICmp0
= new ICmpInst(ICmpInst::ICMP_SGT
, PtrVecA
, PtrVecB
);
319 ICmpInst
*ICmp1
= new ICmpInst(ICmpInst::ICMP_ULT
, PtrVecA
, PtrVecB
);
320 EXPECT_NE(ICmp0
, ICmp1
); // suppress warning.
322 BasicBlock
* BB0
= BasicBlock::Create(C
);
323 // Test InsertAtEnd ICmpInst constructor.
324 ICmpInst
*ICmp2
= new ICmpInst(*BB0
, ICmpInst::ICMP_SGE
, PtrVecA
, PtrVecB
);
325 EXPECT_NE(ICmp0
, ICmp2
); // suppress warning.
327 GetElementPtrInst
*Gep0
= GetElementPtrInst::Create(I32Ty
, PtrVecA
, C2xi32a
);
328 GetElementPtrInst
*Gep1
= GetElementPtrInst::Create(I32Ty
, PtrVecA
, C2xi32b
);
329 GetElementPtrInst
*Gep2
= GetElementPtrInst::Create(I32Ty
, PtrVecB
, C2xi32a
);
330 GetElementPtrInst
*Gep3
= GetElementPtrInst::Create(I32Ty
, PtrVecB
, C2xi32b
);
332 CastInst
*BTC0
= new BitCastInst(Gep0
, V2xi8PTy
);
333 CastInst
*BTC1
= new BitCastInst(Gep1
, V2xi8PTy
);
334 CastInst
*BTC2
= new BitCastInst(Gep2
, V2xi8PTy
);
335 CastInst
*BTC3
= new BitCastInst(Gep3
, V2xi8PTy
);
337 Value
*S0
= BTC0
->stripPointerCasts();
338 Value
*S1
= BTC1
->stripPointerCasts();
339 Value
*S2
= BTC2
->stripPointerCasts();
340 Value
*S3
= BTC3
->stripPointerCasts();
348 DataLayout
TD("e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f3"
349 "2:32:32-f64:64:64-v64:64:64-v128:128:128-a:0:64-s:64:64-f80"
350 ":128:128-n8:16:32:64-S128");
351 // Make sure we don't crash
352 GetPointerBaseWithConstantOffset(Gep0
, Offset
, TD
);
353 GetPointerBaseWithConstantOffset(Gep1
, Offset
, TD
);
354 GetPointerBaseWithConstantOffset(Gep2
, Offset
, TD
);
355 GetPointerBaseWithConstantOffset(Gep3
, Offset
, TD
);
358 GetElementPtrInst
*GepII0
= GetElementPtrInst::Create(I32Ty
, Gep0
, C2xi32b
);
359 GetElementPtrInst
*GepII1
= GetElementPtrInst::Create(I32Ty
, Gep1
, C2xi32a
);
360 GetElementPtrInst
*GepII2
= GetElementPtrInst::Create(I32Ty
, Gep2
, C2xi32b
);
361 GetElementPtrInst
*GepII3
= GetElementPtrInst::Create(I32Ty
, Gep3
, C2xi32a
);
363 EXPECT_EQ(GepII0
->getNumIndices(), 1u);
364 EXPECT_EQ(GepII1
->getNumIndices(), 1u);
365 EXPECT_EQ(GepII2
->getNumIndices(), 1u);
366 EXPECT_EQ(GepII3
->getNumIndices(), 1u);
368 EXPECT_FALSE(GepII0
->hasAllZeroIndices());
369 EXPECT_FALSE(GepII1
->hasAllZeroIndices());
370 EXPECT_FALSE(GepII2
->hasAllZeroIndices());
371 EXPECT_FALSE(GepII3
->hasAllZeroIndices());
388 ICmp2
->eraseFromParent();
397 TEST(InstructionsTest
, FPMathOperator
) {
399 IRBuilder
<> Builder(Context
);
400 MDBuilder
MDHelper(Context
);
401 Instruction
*I
= Builder
.CreatePHI(Builder
.getDoubleTy(), 0);
402 MDNode
*MD1
= MDHelper
.createFPMath(1.0);
403 Value
*V1
= Builder
.CreateFAdd(I
, I
, "", MD1
);
404 EXPECT_TRUE(isa
<FPMathOperator
>(V1
));
405 FPMathOperator
*O1
= cast
<FPMathOperator
>(V1
);
406 EXPECT_EQ(O1
->getFPAccuracy(), 1.0);
412 TEST(InstructionsTest
, isEliminableCastPair
) {
415 Type
* Int16Ty
= Type::getInt16Ty(C
);
416 Type
* Int32Ty
= Type::getInt32Ty(C
);
417 Type
* Int64Ty
= Type::getInt64Ty(C
);
418 Type
* Int64PtrTy
= Type::getInt64PtrTy(C
);
420 // Source and destination pointers have same size -> bitcast.
421 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::PtrToInt
,
423 Int64PtrTy
, Int64Ty
, Int64PtrTy
,
424 Int32Ty
, nullptr, Int32Ty
),
427 // Source and destination have unknown sizes, but the same address space and
428 // the intermediate int is the maximum pointer size -> bitcast
429 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::PtrToInt
,
431 Int64PtrTy
, Int64Ty
, Int64PtrTy
,
432 nullptr, nullptr, nullptr),
435 // Source and destination have unknown sizes, but the same address space and
436 // the intermediate int is not the maximum pointer size -> nothing
437 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::PtrToInt
,
439 Int64PtrTy
, Int32Ty
, Int64PtrTy
,
440 nullptr, nullptr, nullptr),
443 // Middle pointer big enough -> bitcast.
444 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr
,
446 Int64Ty
, Int64PtrTy
, Int64Ty
,
447 nullptr, Int64Ty
, nullptr),
450 // Middle pointer too small -> fail.
451 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr
,
453 Int64Ty
, Int64PtrTy
, Int64Ty
,
454 nullptr, Int32Ty
, nullptr),
457 // Test that we don't eliminate bitcasts between different address spaces,
458 // or if we don't have available pointer size information.
459 DataLayout
DL("e-p:32:32:32-p1:16:16:16-p2:64:64:64-i1:8:8-i8:8:8-i16:16:16"
460 "-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64"
461 "-v128:128:128-a:0:64-s:64:64-f80:128:128-n8:16:32:64-S128");
463 Type
* Int64PtrTyAS1
= Type::getInt64PtrTy(C
, 1);
464 Type
* Int64PtrTyAS2
= Type::getInt64PtrTy(C
, 2);
466 IntegerType
*Int16SizePtr
= DL
.getIntPtrType(C
, 1);
467 IntegerType
*Int64SizePtr
= DL
.getIntPtrType(C
, 2);
469 // Cannot simplify inttoptr, addrspacecast
470 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr
,
471 CastInst::AddrSpaceCast
,
472 Int16Ty
, Int64PtrTyAS1
, Int64PtrTyAS2
,
473 nullptr, Int16SizePtr
, Int64SizePtr
),
476 // Cannot simplify addrspacecast, ptrtoint
477 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::AddrSpaceCast
,
479 Int64PtrTyAS1
, Int64PtrTyAS2
, Int16Ty
,
480 Int64SizePtr
, Int16SizePtr
, nullptr),
483 // Pass since the bitcast address spaces are the same
484 EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr
,
486 Int16Ty
, Int64PtrTyAS1
, Int64PtrTyAS1
,
487 nullptr, nullptr, nullptr),
492 TEST(InstructionsTest
, CloneCall
) {
494 Type
*Int32Ty
= Type::getInt32Ty(C
);
495 Type
*ArgTys
[] = {Int32Ty
, Int32Ty
, Int32Ty
};
496 Type
*FnTy
= FunctionType::get(Int32Ty
, ArgTys
, /*isVarArg=*/false);
497 Value
*Callee
= Constant::getNullValue(FnTy
->getPointerTo());
499 ConstantInt::get(Int32Ty
, 1),
500 ConstantInt::get(Int32Ty
, 2),
501 ConstantInt::get(Int32Ty
, 3)
503 std::unique_ptr
<CallInst
> Call(CallInst::Create(Callee
, Args
, "result"));
505 // Test cloning the tail call kind.
506 CallInst::TailCallKind Kinds
[] = {CallInst::TCK_None
, CallInst::TCK_Tail
,
507 CallInst::TCK_MustTail
};
508 for (CallInst::TailCallKind TCK
: Kinds
) {
509 Call
->setTailCallKind(TCK
);
510 std::unique_ptr
<CallInst
> Clone(cast
<CallInst
>(Call
->clone()));
511 EXPECT_EQ(Call
->getTailCallKind(), Clone
->getTailCallKind());
513 Call
->setTailCallKind(CallInst::TCK_None
);
515 // Test cloning an attribute.
518 AB
.addAttribute(Attribute::ReadOnly
);
519 Call
->setAttributes(AttributeSet::get(C
, AttributeSet::FunctionIndex
, AB
));
520 std::unique_ptr
<CallInst
> Clone(cast
<CallInst
>(Call
->clone()));
521 EXPECT_TRUE(Clone
->onlyReadsMemory());
525 TEST(InstructionsTest
, AlterCallBundles
) {
527 Type
*Int32Ty
= Type::getInt32Ty(C
);
528 Type
*FnTy
= FunctionType::get(Int32Ty
, Int32Ty
, /*isVarArg=*/false);
529 Value
*Callee
= Constant::getNullValue(FnTy
->getPointerTo());
530 Value
*Args
[] = {ConstantInt::get(Int32Ty
, 42)};
531 OperandBundleDef
OldBundle("before", UndefValue::get(Int32Ty
));
532 std::unique_ptr
<CallInst
> Call(
533 CallInst::Create(Callee
, Args
, OldBundle
, "result"));
534 Call
->setTailCallKind(CallInst::TailCallKind::TCK_NoTail
);
536 AB
.addAttribute(Attribute::Cold
);
537 Call
->setAttributes(AttributeSet::get(C
, AttributeSet::FunctionIndex
, AB
));
538 Call
->setDebugLoc(DebugLoc(MDNode::get(C
, None
)));
540 OperandBundleDef
NewBundle("after", ConstantInt::get(Int32Ty
, 7));
541 std::unique_ptr
<CallInst
> Clone(CallInst::Create(Call
.get(), NewBundle
));
542 EXPECT_EQ(Call
->getNumArgOperands(), Clone
->getNumArgOperands());
543 EXPECT_EQ(Call
->getArgOperand(0), Clone
->getArgOperand(0));
544 EXPECT_EQ(Call
->getCallingConv(), Clone
->getCallingConv());
545 EXPECT_EQ(Call
->getTailCallKind(), Clone
->getTailCallKind());
546 EXPECT_TRUE(Clone
->hasFnAttr(Attribute::AttrKind::Cold
));
547 EXPECT_EQ(Call
->getDebugLoc(), Clone
->getDebugLoc());
548 EXPECT_EQ(Clone
->getNumOperandBundles(), 1U);
549 EXPECT_TRUE(Clone
->getOperandBundle("after").hasValue());
552 TEST(InstructionsTest
, AlterInvokeBundles
) {
554 Type
*Int32Ty
= Type::getInt32Ty(C
);
555 Type
*FnTy
= FunctionType::get(Int32Ty
, Int32Ty
, /*isVarArg=*/false);
556 Value
*Callee
= Constant::getNullValue(FnTy
->getPointerTo());
557 Value
*Args
[] = {ConstantInt::get(Int32Ty
, 42)};
558 std::unique_ptr
<BasicBlock
> NormalDest(BasicBlock::Create(C
));
559 std::unique_ptr
<BasicBlock
> UnwindDest(BasicBlock::Create(C
));
560 OperandBundleDef
OldBundle("before", UndefValue::get(Int32Ty
));
561 std::unique_ptr
<InvokeInst
> Invoke(InvokeInst::Create(
562 Callee
, NormalDest
.get(), UnwindDest
.get(), Args
, OldBundle
, "result"));
564 AB
.addAttribute(Attribute::Cold
);
565 Invoke
->setAttributes(AttributeSet::get(C
, AttributeSet::FunctionIndex
, AB
));
566 Invoke
->setDebugLoc(DebugLoc(MDNode::get(C
, None
)));
568 OperandBundleDef
NewBundle("after", ConstantInt::get(Int32Ty
, 7));
569 std::unique_ptr
<InvokeInst
> Clone(
570 InvokeInst::Create(Invoke
.get(), NewBundle
));
571 EXPECT_EQ(Invoke
->getNormalDest(), Clone
->getNormalDest());
572 EXPECT_EQ(Invoke
->getUnwindDest(), Clone
->getUnwindDest());
573 EXPECT_EQ(Invoke
->getNumArgOperands(), Clone
->getNumArgOperands());
574 EXPECT_EQ(Invoke
->getArgOperand(0), Clone
->getArgOperand(0));
575 EXPECT_EQ(Invoke
->getCallingConv(), Clone
->getCallingConv());
576 EXPECT_TRUE(Clone
->hasFnAttr(Attribute::AttrKind::Cold
));
577 EXPECT_EQ(Invoke
->getDebugLoc(), Clone
->getDebugLoc());
578 EXPECT_EQ(Clone
->getNumOperandBundles(), 1U);
579 EXPECT_TRUE(Clone
->getOperandBundle("after").hasValue());
582 } // end anonymous namespace
583 } // end namespace llvm