PageRenderTime 37ms CodeModel.GetById 20ms app.highlight 15ms RepoModel.GetById 0ms app.codeStats 0ms

/3rd_party/llvm/unittests/VMCore/InstructionsTest.cpp

https://code.google.com/p/softart/
C++ | 247 lines | 173 code | 50 blank | 24 comment | 0 complexity | 37191298d982e20caaec0ef91d7a9282 MD5 | raw file
Possible License(s): LGPL-2.1, BSD-3-Clause, JSON, MPL-2.0-no-copyleft-exception, GPL-2.0, GPL-3.0, LGPL-3.0, BSD-2-Clause
  1//===- llvm/unittest/VMCore/InstructionsTest.cpp - Instructions unit tests ===//
  2//
  3//                     The LLVM Compiler Infrastructure
  4//
  5// This file is distributed under the University of Illinois Open Source
  6// License. See LICENSE.TXT for details.
  7//
  8//===----------------------------------------------------------------------===//
  9
 10#include "llvm/BasicBlock.h"
 11#include "llvm/Constants.h"
 12#include "llvm/DerivedTypes.h"
 13#include "llvm/IRBuilder.h"
 14#include "llvm/Instructions.h"
 15#include "llvm/LLVMContext.h"
 16#include "llvm/MDBuilder.h"
 17#include "llvm/Operator.h"
 18#include "llvm/ADT/STLExtras.h"
 19#include "llvm/Analysis/ValueTracking.h"
 20#include "llvm/Target/TargetData.h"
 21#include "gtest/gtest.h"
 22
 23namespace llvm {
 24namespace {
 25
 26TEST(InstructionsTest, ReturnInst) {
 27  LLVMContext &C(getGlobalContext());
 28
 29  // test for PR6589
 30  const ReturnInst* r0 = ReturnInst::Create(C);
 31  EXPECT_EQ(r0->getNumOperands(), 0U);
 32  EXPECT_EQ(r0->op_begin(), r0->op_end());
 33
 34  IntegerType* Int1 = IntegerType::get(C, 1);
 35  Constant* One = ConstantInt::get(Int1, 1, true);
 36  const ReturnInst* r1 = ReturnInst::Create(C, One);
 37  EXPECT_EQ(1U, r1->getNumOperands());
 38  User::const_op_iterator b(r1->op_begin());
 39  EXPECT_NE(r1->op_end(), b);
 40  EXPECT_EQ(One, *b);
 41  EXPECT_EQ(One, r1->getOperand(0));
 42  ++b;
 43  EXPECT_EQ(r1->op_end(), b);
 44
 45  // clean up
 46  delete r0;
 47  delete r1;
 48}
 49
 50TEST(InstructionsTest, BranchInst) {
 51  LLVMContext &C(getGlobalContext());
 52
 53  // Make a BasicBlocks
 54  BasicBlock* bb0 = BasicBlock::Create(C);
 55  BasicBlock* bb1 = BasicBlock::Create(C);
 56
 57  // Mandatory BranchInst
 58  const BranchInst* b0 = BranchInst::Create(bb0);
 59
 60  EXPECT_TRUE(b0->isUnconditional());
 61  EXPECT_FALSE(b0->isConditional());
 62  EXPECT_EQ(1U, b0->getNumSuccessors());
 63
 64  // check num operands
 65  EXPECT_EQ(1U, b0->getNumOperands());
 66
 67  EXPECT_NE(b0->op_begin(), b0->op_end());
 68  EXPECT_EQ(b0->op_end(), llvm::next(b0->op_begin()));
 69
 70  EXPECT_EQ(b0->op_end(), llvm::next(b0->op_begin()));
 71
 72  IntegerType* Int1 = IntegerType::get(C, 1);
 73  Constant* One = ConstantInt::get(Int1, 1, true);
 74
 75  // Conditional BranchInst
 76  BranchInst* b1 = BranchInst::Create(bb0, bb1, One);
 77
 78  EXPECT_FALSE(b1->isUnconditional());
 79  EXPECT_TRUE(b1->isConditional());
 80  EXPECT_EQ(2U, b1->getNumSuccessors());
 81
 82  // check num operands
 83  EXPECT_EQ(3U, b1->getNumOperands());
 84
 85  User::const_op_iterator b(b1->op_begin());
 86
 87  // check COND
 88  EXPECT_NE(b, b1->op_end());
 89  EXPECT_EQ(One, *b);
 90  EXPECT_EQ(One, b1->getOperand(0));
 91  EXPECT_EQ(One, b1->getCondition());
 92  ++b;
 93
 94  // check ELSE
 95  EXPECT_EQ(bb1, *b);
 96  EXPECT_EQ(bb1, b1->getOperand(1));
 97  EXPECT_EQ(bb1, b1->getSuccessor(1));
 98  ++b;
 99
100  // check THEN
101  EXPECT_EQ(bb0, *b);
102  EXPECT_EQ(bb0, b1->getOperand(2));
103  EXPECT_EQ(bb0, b1->getSuccessor(0));
104  ++b;
105
106  EXPECT_EQ(b1->op_end(), b);
107
108  // clean up
109  delete b0;
110  delete b1;
111
112  delete bb0;
113  delete bb1;
114}
115
116TEST(InstructionsTest, CastInst) {
117  LLVMContext &C(getGlobalContext());
118
119  Type* Int8Ty = Type::getInt8Ty(C);
120  Type* Int64Ty = Type::getInt64Ty(C);
121  Type* V8x8Ty = VectorType::get(Int8Ty, 8);
122  Type* V8x64Ty = VectorType::get(Int64Ty, 8);
123  Type* X86MMXTy = Type::getX86_MMXTy(C);
124
125  const Constant* c8 = Constant::getNullValue(V8x8Ty);
126  const Constant* c64 = Constant::getNullValue(V8x64Ty);
127
128  EXPECT_TRUE(CastInst::isCastable(V8x8Ty, X86MMXTy));
129  EXPECT_TRUE(CastInst::isCastable(X86MMXTy, V8x8Ty));
130  EXPECT_FALSE(CastInst::isCastable(Int64Ty, X86MMXTy));
131  EXPECT_TRUE(CastInst::isCastable(V8x64Ty, V8x8Ty));
132  EXPECT_TRUE(CastInst::isCastable(V8x8Ty, V8x64Ty));
133  EXPECT_EQ(CastInst::Trunc, CastInst::getCastOpcode(c64, true, V8x8Ty, true));
134  EXPECT_EQ(CastInst::SExt, CastInst::getCastOpcode(c8, true, V8x64Ty, true));
135}
136
137
138
139TEST(InstructionsTest, VectorGep) {
140  LLVMContext &C(getGlobalContext());
141
142  // Type Definitions
143  PointerType *Ptri8Ty = PointerType::get(IntegerType::get(C, 8), 0);
144  PointerType *Ptri32Ty = PointerType::get(IntegerType::get(C, 8), 0);
145
146  VectorType *V2xi8PTy = VectorType::get(Ptri8Ty, 2);
147  VectorType *V2xi32PTy = VectorType::get(Ptri32Ty, 2);
148
149  // Test different aspects of the vector-of-pointers type
150  // and GEPs which use this type.
151  ConstantInt *Ci32a = ConstantInt::get(C, APInt(32, 1492));
152  ConstantInt *Ci32b = ConstantInt::get(C, APInt(32, 1948));
153  std::vector<Constant*> ConstVa(2, Ci32a);
154  std::vector<Constant*> ConstVb(2, Ci32b);
155  Constant *C2xi32a = ConstantVector::get(ConstVa);
156  Constant *C2xi32b = ConstantVector::get(ConstVb);
157
158  CastInst *PtrVecA = new IntToPtrInst(C2xi32a, V2xi32PTy);
159  CastInst *PtrVecB = new IntToPtrInst(C2xi32b, V2xi32PTy);
160
161  ICmpInst *ICmp0 = new ICmpInst(ICmpInst::ICMP_SGT, PtrVecA, PtrVecB);
162  ICmpInst *ICmp1 = new ICmpInst(ICmpInst::ICMP_ULT, PtrVecA, PtrVecB);
163  EXPECT_NE(ICmp0, ICmp1); // suppress warning.
164
165  GetElementPtrInst *Gep0 = GetElementPtrInst::Create(PtrVecA, C2xi32a);
166  GetElementPtrInst *Gep1 = GetElementPtrInst::Create(PtrVecA, C2xi32b);
167  GetElementPtrInst *Gep2 = GetElementPtrInst::Create(PtrVecB, C2xi32a);
168  GetElementPtrInst *Gep3 = GetElementPtrInst::Create(PtrVecB, C2xi32b);
169
170  CastInst *BTC0 = new BitCastInst(Gep0, V2xi8PTy);
171  CastInst *BTC1 = new BitCastInst(Gep1, V2xi8PTy);
172  CastInst *BTC2 = new BitCastInst(Gep2, V2xi8PTy);
173  CastInst *BTC3 = new BitCastInst(Gep3, V2xi8PTy);
174
175  Value *S0 = BTC0->stripPointerCasts();
176  Value *S1 = BTC1->stripPointerCasts();
177  Value *S2 = BTC2->stripPointerCasts();
178  Value *S3 = BTC3->stripPointerCasts();
179
180  EXPECT_NE(S0, Gep0);
181  EXPECT_NE(S1, Gep1);
182  EXPECT_NE(S2, Gep2);
183  EXPECT_NE(S3, Gep3);
184
185  int64_t Offset;
186  TargetData TD("e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f3"
187                "2:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80"
188                ":128:128-n8:16:32:64-S128");
189  // Make sure we don't crash
190  GetPointerBaseWithConstantOffset(Gep0, Offset, TD);
191  GetPointerBaseWithConstantOffset(Gep1, Offset, TD);
192  GetPointerBaseWithConstantOffset(Gep2, Offset, TD);
193  GetPointerBaseWithConstantOffset(Gep3, Offset, TD);
194
195  // Gep of Geps
196  GetElementPtrInst *GepII0 = GetElementPtrInst::Create(Gep0, C2xi32b);
197  GetElementPtrInst *GepII1 = GetElementPtrInst::Create(Gep1, C2xi32a);
198  GetElementPtrInst *GepII2 = GetElementPtrInst::Create(Gep2, C2xi32b);
199  GetElementPtrInst *GepII3 = GetElementPtrInst::Create(Gep3, C2xi32a);
200
201  EXPECT_EQ(GepII0->getNumIndices(), 1u);
202  EXPECT_EQ(GepII1->getNumIndices(), 1u);
203  EXPECT_EQ(GepII2->getNumIndices(), 1u);
204  EXPECT_EQ(GepII3->getNumIndices(), 1u);
205
206  EXPECT_FALSE(GepII0->hasAllZeroIndices());
207  EXPECT_FALSE(GepII1->hasAllZeroIndices());
208  EXPECT_FALSE(GepII2->hasAllZeroIndices());
209  EXPECT_FALSE(GepII3->hasAllZeroIndices());
210
211  delete GepII0;
212  delete GepII1;
213  delete GepII2;
214  delete GepII3;
215
216  delete BTC0;
217  delete BTC1;
218  delete BTC2;
219  delete BTC3;
220
221  delete Gep0;
222  delete Gep1;
223  delete Gep2;
224  delete Gep3;
225
226  delete ICmp0;
227  delete ICmp1;
228  delete PtrVecA;
229  delete PtrVecB;
230}
231
232TEST(InstructionsTest, FPMathOperator) {
233  LLVMContext &Context = getGlobalContext();
234  IRBuilder<> Builder(Context);
235  MDBuilder MDHelper(Context);
236  Instruction *I = Builder.CreatePHI(Builder.getDoubleTy(), 0);
237  MDNode *MD1 = MDHelper.createFPMath(1.0);
238  Value *V1 = Builder.CreateFAdd(I, I, "", MD1);
239  EXPECT_TRUE(isa<FPMathOperator>(V1));
240  FPMathOperator *O1 = cast<FPMathOperator>(V1);
241  EXPECT_EQ(O1->getFPAccuracy(), 1.0);
242  delete V1;
243  delete I;
244}
245
246}  // end anonymous namespace
247}  // end namespace llvm