unittests/VMCore/InstructionsTest.cpp

   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/Instructions.h"
  11 #include "llvm/BasicBlock.h"
  12 #include "llvm/DerivedTypes.h"
  13 #include "llvm/LLVMContext.h"
  14 #include "gtest/gtest.h"
  15
  16 namespace llvm {
  17 namespace {
  18
  19 TEST(InstructionsTest, ReturnInst) {
  20   LLVMContext &C(getGlobalContext());
  21
  22   // test for PR6589
  23   const ReturnInst* r0 = ReturnInst::Create(C);
  24   EXPECT_EQ(r0->getNumOperands(), 0U);
  25   EXPECT_EQ(r0->op_begin(), r0->op_end());
  26
  27   const IntegerType* Int1 = IntegerType::get(C, 1);
  28   Constant* One = ConstantInt::get(Int1, 1, true);
  29   const ReturnInst* r1 = ReturnInst::Create(C, One);
  30   EXPECT_EQ(r1->getNumOperands(), 1U);
  31   User::const_op_iterator b(r1->op_begin());
  32   EXPECT_NE(b, r1->op_end());
  33   EXPECT_EQ(*b, One);
  34   EXPECT_EQ(r1->getOperand(0), One);
  35   ++b;
  36   EXPECT_EQ(b, r1->op_end());
  37
  38   // clean up
  39   delete r0;
  40   delete r1;
  41 }
  42
  43 TEST(InstructionsTest, BranchInst) {
  44   LLVMContext &C(getGlobalContext());
  45
  46   // Make a BasicBlocks
  47   BasicBlock* bb0 = BasicBlock::Create(C);
  48   BasicBlock* bb1 = BasicBlock::Create(C);
  49
  50   // Mandatory BranchInst
  51   const BranchInst* b0 = BranchInst::Create(bb0);
  52
  53   EXPECT_TRUE(b0->isUnconditional());
  54   EXPECT_FALSE(b0->isConditional());
  55   EXPECT_EQ(b0->getNumSuccessors(), 1U);
  56
  57   // check num operands
  58   EXPECT_EQ(b0->getNumOperands(), 1U);
  59
  60   EXPECT_NE(b0->op_begin(), b0->op_end());
  61   EXPECT_EQ(b0->op_begin() + 1, b0->op_end());
  62
  63   EXPECT_EQ(b0->op_begin() + 1, b0->op_end());
  64
  65   const IntegerType* Int1 = IntegerType::get(C, 1);
  66   Constant* One = ConstantInt::get(Int1, 1, true);
  67
  68   // Conditional BranchInst
  69   BranchInst* b1 = BranchInst::Create(bb0, bb1, One);
  70
  71   EXPECT_FALSE(b1->isUnconditional());
  72   EXPECT_TRUE(b1->isConditional());
  73   EXPECT_EQ(b1->getNumSuccessors(), 2U);
  74
  75   // check num operands
  76   EXPECT_EQ(b1->getNumOperands(), 3U);
  77
  78   User::const_op_iterator b(b1->op_begin());
  79
  80   // check COND
  81   EXPECT_NE(b, b1->op_end());
  82   EXPECT_EQ(*b, One);
  83   EXPECT_EQ(b1->getOperand(0), One);
  84   EXPECT_EQ(b1->getCondition(), One);
  85   ++b;
  86
  87   // check ELSE
  88   EXPECT_EQ(*b, bb1);
  89   EXPECT_EQ(b1->getOperand(1), bb1);
  90   EXPECT_EQ(b1->getSuccessor(1), bb1);
  91   ++b;
  92
  93   // check THEN
  94   EXPECT_EQ(*b, bb0);
  95   EXPECT_EQ(b1->getOperand(2), bb0);
  96   EXPECT_EQ(b1->getSuccessor(0), bb0);
  97   ++b;
  98
  99   EXPECT_EQ(b, b1->op_end());
 100
 101   // shrink it
 102   b1->setUnconditionalDest(bb1);
 103
 104   // check num operands
 105   EXPECT_EQ(b1->getNumOperands(), 1U);
 106
 107   User::const_op_iterator c(b1->op_begin());
 108   EXPECT_NE(c, b1->op_end());
 109
 110   // check THEN
 111   EXPECT_EQ(*c, bb1);
 112   EXPECT_EQ(b1->getOperand(0), bb1);
 113   EXPECT_EQ(b1->getSuccessor(0), bb1);
 114   ++c;
 115
 116   EXPECT_EQ(c, b1->op_end());
 117
 118   // clean up
 119   delete b0;
 120   delete b1;
 121
 122   delete bb0;
 123   delete bb1;
 124 }
 125
 126 }  // end anonymous namespace
 127 }  // end namespace llvm