unittests/IR/FunctionTest.cpp

   1 //===- FunctionTest.cpp - Function unit tests -----------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/IR/Function.h"
  10 #include "llvm/IR/Module.h"
  11 #include "gtest/gtest.h"
  12 using namespace llvm;
  13
  14 namespace {
  15
  16 TEST(FunctionTest, hasLazyArguments) {
  17   LLVMContext C;
  18
  19   Type *ArgTypes[] = {Type::getInt8Ty(C), Type::getInt32Ty(C)};
  20   FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), ArgTypes, false);
  21
  22   // Functions start out with lazy arguments.
  23   std::unique_ptr<Function> F(
  24       Function::Create(FTy, GlobalValue::ExternalLinkage, "F"));
  25   EXPECT_TRUE(F->hasLazyArguments());
  26
  27   // Checking for empty or size shouldn't force arguments to be instantiated.
  28   EXPECT_FALSE(F->arg_empty());
  29   EXPECT_TRUE(F->hasLazyArguments());
  30   EXPECT_EQ(2u, F->arg_size());
  31   EXPECT_TRUE(F->hasLazyArguments());
  32
  33   // The argument list should be populated at first access.
  34   (void)F->arg_begin();
  35   EXPECT_FALSE(F->hasLazyArguments());
  36
  37   // Checking that getArg gets the arguments from F1 in the correct order.
  38   unsigned i = 0;
  39   for (Argument &A : F->args()) {
  40     EXPECT_EQ(&A, F->getArg(i));
  41     ++i;
  42   }
  43   EXPECT_FALSE(F->hasLazyArguments());
  44 }
  45
  46 TEST(FunctionTest, stealArgumentListFrom) {
  47   LLVMContext C;
  48
  49   Type *ArgTypes[] = {Type::getInt8Ty(C), Type::getInt32Ty(C)};
  50   FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), ArgTypes, false);
  51   std::unique_ptr<Function> F1(
  52       Function::Create(FTy, GlobalValue::ExternalLinkage, "F1"));
  53   std::unique_ptr<Function> F2(
  54       Function::Create(FTy, GlobalValue::ExternalLinkage, "F1"));
  55   EXPECT_TRUE(F1->hasLazyArguments());
  56   EXPECT_TRUE(F2->hasLazyArguments());
  57
  58   // Steal arguments before they've been accessed.  Nothing should change; both
  59   // functions should still have lazy arguments.
  60   //
  61   //   steal(empty); drop (empty)
  62   F1->stealArgumentListFrom(*F2);
  63   EXPECT_TRUE(F1->hasLazyArguments());
  64   EXPECT_TRUE(F2->hasLazyArguments());
  65
  66   // Save arguments from F1 for later assertions.  F1 won't have lazy arguments
  67   // anymore.
  68   SmallVector<Argument *, 4> Args;
  69   for (Argument &A : F1->args())
  70     Args.push_back(&A);
  71   EXPECT_EQ(2u, Args.size());
  72   EXPECT_FALSE(F1->hasLazyArguments());
  73
  74   // Steal arguments from F1 to F2.  F1's arguments should be lazy again.
  75   //
  76   //   steal(real); drop (empty)
  77   F2->stealArgumentListFrom(*F1);
  78   EXPECT_TRUE(F1->hasLazyArguments());
  79   EXPECT_FALSE(F2->hasLazyArguments());
  80   unsigned I = 0;
  81   for (Argument &A : F2->args()) {
  82     EXPECT_EQ(Args[I], &A);
  83     I++;
  84   }
  85   EXPECT_EQ(2u, I);
  86
  87   // Check that arguments in F1 don't have pointer equality with the saved ones.
  88   // This also instantiates F1's arguments.
  89   I = 0;
  90   for (Argument &A : F1->args()) {
  91     EXPECT_NE(Args[I], &A);
  92     I++;
  93   }
  94   EXPECT_EQ(2u, I);
  95   EXPECT_FALSE(F1->hasLazyArguments());
  96   EXPECT_FALSE(F2->hasLazyArguments());
  97
  98   // Steal back from F2.  F2's arguments should be lazy again.
  99   //
 100   //   steal(real); drop (real)
 101   F1->stealArgumentListFrom(*F2);
 102   EXPECT_FALSE(F1->hasLazyArguments());
 103   EXPECT_TRUE(F2->hasLazyArguments());
 104   I = 0;
 105   for (Argument &A : F1->args()) {
 106     EXPECT_EQ(Args[I], &A);
 107     I++;
 108   }
 109   EXPECT_EQ(2u, I);
 110
 111   // Steal from F2 a second time.  Now both functions should have lazy
 112   // arguments.
 113   //
 114   //   steal(empty); drop (real)
 115   F1->stealArgumentListFrom(*F2);
 116   EXPECT_TRUE(F1->hasLazyArguments());
 117   EXPECT_TRUE(F2->hasLazyArguments());
 118 }
 119
 120 // Test setting and removing section information
 121 TEST(FunctionTest, setSection) {
 122   LLVMContext C;
 123   Module M("test", C);
 124
 125   llvm::Function *F =
 126       Function::Create(llvm::FunctionType::get(llvm::Type::getVoidTy(C), false),
 127                        llvm::GlobalValue::ExternalLinkage, "F", &M);
 128
 129   F->setSection(".text.test");
 130   EXPECT_TRUE(F->getSection() == ".text.test");
 131   EXPECT_TRUE(F->hasSection());
 132   F->setSection("");
 133   EXPECT_FALSE(F->hasSection());
 134   F->setSection(".text.test");
 135   F->setSection(".text.test2");
 136   EXPECT_TRUE(F->getSection() == ".text.test2");
 137   EXPECT_TRUE(F->hasSection());
 138 }
 139
 140 TEST(FunctionTest, GetPointerAlignment) {
 141   LLVMContext Context;
 142   Type *VoidType(Type::getVoidTy(Context));
 143   FunctionType *FuncType(FunctionType::get(VoidType, false));
 144   std::unique_ptr<Function> Func(Function::Create(
 145       FuncType, GlobalValue::ExternalLinkage));
 146   EXPECT_EQ(0U, Func->getPointerAlignment(DataLayout("")));
 147   EXPECT_EQ(1U, Func->getPointerAlignment(DataLayout("Fi8")));
 148   EXPECT_EQ(1U, Func->getPointerAlignment(DataLayout("Fn8")));
 149   EXPECT_EQ(2U, Func->getPointerAlignment(DataLayout("Fi16")));
 150   EXPECT_EQ(2U, Func->getPointerAlignment(DataLayout("Fn16")));
 151   EXPECT_EQ(4U, Func->getPointerAlignment(DataLayout("Fi32")));
 152   EXPECT_EQ(4U, Func->getPointerAlignment(DataLayout("Fn32")));
 153
 154   Func->setAlignment(4U);
 155
 156   EXPECT_EQ(0U, Func->getPointerAlignment(DataLayout("")));
 157   EXPECT_EQ(1U, Func->getPointerAlignment(DataLayout("Fi8")));
 158   EXPECT_EQ(4U, Func->getPointerAlignment(DataLayout("Fn8")));
 159   EXPECT_EQ(2U, Func->getPointerAlignment(DataLayout("Fi16")));
 160   EXPECT_EQ(4U, Func->getPointerAlignment(DataLayout("Fn16")));
 161   EXPECT_EQ(4U, Func->getPointerAlignment(DataLayout("Fi32")));
 162   EXPECT_EQ(4U, Func->getPointerAlignment(DataLayout("Fn32")));
 163 }
 164
 165 } // end namespace