unittests/IR/FunctionTest.cpp

   1 //===- FunctionTest.cpp - Function 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/IR/Function.h"
  11 #include "llvm/IR/Module.h"
  12 #include "gtest/gtest.h"
  13 using namespace llvm;
  14
  15 namespace {
  16
  17 TEST(FunctionTest, hasLazyArguments) {
  18   LLVMContext C;
  19
  20   Type *ArgTypes[] = {Type::getInt8Ty(C), Type::getInt32Ty(C)};
  21   FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), ArgTypes, false);
  22
  23   // Functions start out with lazy arguments.
  24   std::unique_ptr<Function> F(
  25       Function::Create(FTy, GlobalValue::ExternalLinkage, "F"));
  26   EXPECT_TRUE(F->hasLazyArguments());
  27
  28   // Checking for empty or size shouldn't force arguments to be instantiated.
  29   EXPECT_FALSE(F->arg_empty());
  30   EXPECT_TRUE(F->hasLazyArguments());
  31   EXPECT_EQ(2u, F->arg_size());
  32   EXPECT_TRUE(F->hasLazyArguments());
  33
  34   // The argument list should be populated at first access.
  35   (void)F->arg_begin();
  36   EXPECT_FALSE(F->hasLazyArguments());
  37 }
  38
  39 TEST(FunctionTest, stealArgumentListFrom) {
  40   LLVMContext C;
  41
  42   Type *ArgTypes[] = {Type::getInt8Ty(C), Type::getInt32Ty(C)};
  43   FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), ArgTypes, false);
  44   std::unique_ptr<Function> F1(
  45       Function::Create(FTy, GlobalValue::ExternalLinkage, "F1"));
  46   std::unique_ptr<Function> F2(
  47       Function::Create(FTy, GlobalValue::ExternalLinkage, "F1"));
  48   EXPECT_TRUE(F1->hasLazyArguments());
  49   EXPECT_TRUE(F2->hasLazyArguments());
  50
  51   // Steal arguments before they've been accessed.  Nothing should change; both
  52   // functions should still have lazy arguments.
  53   //
  54   //   steal(empty); drop (empty)
  55   F1->stealArgumentListFrom(*F2);
  56   EXPECT_TRUE(F1->hasLazyArguments());
  57   EXPECT_TRUE(F2->hasLazyArguments());
  58
  59   // Save arguments from F1 for later assertions.  F1 won't have lazy arguments
  60   // anymore.
  61   SmallVector<Argument *, 4> Args;
  62   for (Argument &A : F1->args())
  63     Args.push_back(&A);
  64   EXPECT_EQ(2u, Args.size());
  65   EXPECT_FALSE(F1->hasLazyArguments());
  66
  67   // Steal arguments from F1 to F2.  F1's arguments should be lazy again.
  68   //
  69   //   steal(real); drop (empty)
  70   F2->stealArgumentListFrom(*F1);
  71   EXPECT_TRUE(F1->hasLazyArguments());
  72   EXPECT_FALSE(F2->hasLazyArguments());
  73   unsigned I = 0;
  74   for (Argument &A : F2->args()) {
  75     EXPECT_EQ(Args[I], &A);
  76     I++;
  77   }
  78   EXPECT_EQ(2u, I);
  79
  80   // Check that arguments in F1 don't have pointer equality with the saved ones.
  81   // This also instantiates F1's arguments.
  82   I = 0;
  83   for (Argument &A : F1->args()) {
  84     EXPECT_NE(Args[I], &A);
  85     I++;
  86   }
  87   EXPECT_EQ(2u, I);
  88   EXPECT_FALSE(F1->hasLazyArguments());
  89   EXPECT_FALSE(F2->hasLazyArguments());
  90
  91   // Steal back from F2.  F2's arguments should be lazy again.
  92   //
  93   //   steal(real); drop (real)
  94   F1->stealArgumentListFrom(*F2);
  95   EXPECT_FALSE(F1->hasLazyArguments());
  96   EXPECT_TRUE(F2->hasLazyArguments());
  97   I = 0;
  98   for (Argument &A : F1->args()) {
  99     EXPECT_EQ(Args[I], &A);
 100     I++;
 101   }
 102   EXPECT_EQ(2u, I);
 103
 104   // Steal from F2 a second time.  Now both functions should have lazy
 105   // arguments.
 106   //
 107   //   steal(empty); drop (real)
 108   F1->stealArgumentListFrom(*F2);
 109   EXPECT_TRUE(F1->hasLazyArguments());
 110   EXPECT_TRUE(F2->hasLazyArguments());
 111 }
 112
 113 // Test setting and removing section information
 114 TEST(FunctionTest, setSection) {
 115   LLVMContext C;
 116   Module M("test", C);
 117
 118   llvm::Function *F =
 119       Function::Create(llvm::FunctionType::get(llvm::Type::getVoidTy(C), false),
 120                        llvm::GlobalValue::ExternalLinkage, "F", &M);
 121
 122   F->setSection(".text.test");
 123   EXPECT_TRUE(F->getSection() == ".text.test");
 124   EXPECT_TRUE(F->hasSection());
 125   F->setSection("");
 126   EXPECT_FALSE(F->hasSection());
 127   F->setSection(".text.test");
 128   F->setSection(".text.test2");
 129   EXPECT_TRUE(F->getSection() == ".text.test2");
 130   EXPECT_TRUE(F->hasSection());
 131 }
 132
 133 } // end namespace