Make SpecialCaseList match full strings, as documented, using anchors.

[oota-llvm.git] / unittests / Transforms / Utils / Cloning.cpp

diff --git a/unittests/Transforms/Utils/Cloning.cpp b/unittests/Transforms/Utils/Cloning.cpp
index 17047e7ca15a5f8f3c0cd35b9b49ba6158fa5a7d..e19ae5bc2fb4be6d6eb9f274189e935aa8b5d3f6 100644 (file)
--- a/unittests/Transforms/Utils/Cloning.cpp
+++ b/unittests/Transforms/Utils/Cloning.cpp
@@ -7,82 +7,170 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/IR/Argument.h"
+#include "llvm/IR/Constant.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/Transforms/Utils/Cloning.h"
 #include "gtest/gtest.h"
-#include "llvm/Argument.h"
-#include "llvm/Instructions.h"
-#include "llvm/LLVMContext.h"
 
 using namespace llvm;
 
-TEST(CloneInstruction, OverflowBits) {
+namespace {
+
+class CloneInstruction : public ::testing::Test {
+protected:
+  virtual void SetUp() {
+    V = NULL;
+  }
+
+  template <typename T>
+  T *clone(T *V1) {
+    Value *V2 = V1->clone();
+    Orig.insert(V1);
+    Clones.insert(V2);
+    return cast<T>(V2);
+  }
+
+  void eraseClones() {
+    DeleteContainerPointers(Clones);
+  }
+
+  virtual void TearDown() {
+    eraseClones();
+    DeleteContainerPointers(Orig);
+    delete V;
+  }
+
+  SmallPtrSet<Value *, 4> Orig;   // Erase on exit
+  SmallPtrSet<Value *, 4> Clones; // Erase in eraseClones
+
   LLVMContext context;
-  Value *V = new Argument(Type::getInt32Ty(context));
+  Value *V;
+};
+
+TEST_F(CloneInstruction, OverflowBits) {
+  V = new Argument(Type::getInt32Ty(context));
 
   BinaryOperator *Add = BinaryOperator::Create(Instruction::Add, V, V);
   BinaryOperator *Sub = BinaryOperator::Create(Instruction::Sub, V, V);
   BinaryOperator *Mul = BinaryOperator::Create(Instruction::Mul, V, V);
 
-  EXPECT_FALSE(cast<BinaryOperator>(Add->clone())->hasNoUnsignedWrap());
-  EXPECT_FALSE(cast<BinaryOperator>(Add->clone())->hasNoSignedWrap());
-  EXPECT_FALSE(cast<BinaryOperator>(Sub->clone())->hasNoUnsignedWrap());
-  EXPECT_FALSE(cast<BinaryOperator>(Sub->clone())->hasNoSignedWrap());
-  EXPECT_FALSE(cast<BinaryOperator>(Mul->clone())->hasNoUnsignedWrap());
-  EXPECT_FALSE(cast<BinaryOperator>(Mul->clone())->hasNoSignedWrap());
+  BinaryOperator *AddClone = this->clone(Add);
+  BinaryOperator *SubClone = this->clone(Sub);
+  BinaryOperator *MulClone = this->clone(Mul);
+
+  EXPECT_FALSE(AddClone->hasNoUnsignedWrap());
+  EXPECT_FALSE(AddClone->hasNoSignedWrap());
+  EXPECT_FALSE(SubClone->hasNoUnsignedWrap());
+  EXPECT_FALSE(SubClone->hasNoSignedWrap());
+  EXPECT_FALSE(MulClone->hasNoUnsignedWrap());
+  EXPECT_FALSE(MulClone->hasNoSignedWrap());
+
+  eraseClones();
 
   Add->setHasNoUnsignedWrap();
   Sub->setHasNoUnsignedWrap();
   Mul->setHasNoUnsignedWrap();
 
-  EXPECT_TRUE(cast<BinaryOperator>(Add->clone())->hasNoUnsignedWrap());
-  EXPECT_FALSE(cast<BinaryOperator>(Add->clone())->hasNoSignedWrap());
-  EXPECT_TRUE(cast<BinaryOperator>(Sub->clone())->hasNoUnsignedWrap());
-  EXPECT_FALSE(cast<BinaryOperator>(Sub->clone())->hasNoSignedWrap());
-  EXPECT_TRUE(cast<BinaryOperator>(Mul->clone())->hasNoUnsignedWrap());
-  EXPECT_FALSE(cast<BinaryOperator>(Mul->clone())->hasNoSignedWrap());
+  AddClone = this->clone(Add);
+  SubClone = this->clone(Sub);
+  MulClone = this->clone(Mul);
+
+  EXPECT_TRUE(AddClone->hasNoUnsignedWrap());
+  EXPECT_FALSE(AddClone->hasNoSignedWrap());
+  EXPECT_TRUE(SubClone->hasNoUnsignedWrap());
+  EXPECT_FALSE(SubClone->hasNoSignedWrap());
+  EXPECT_TRUE(MulClone->hasNoUnsignedWrap());
+  EXPECT_FALSE(MulClone->hasNoSignedWrap());
+
+  eraseClones();
 
   Add->setHasNoSignedWrap();
   Sub->setHasNoSignedWrap();
   Mul->setHasNoSignedWrap();
 
-  EXPECT_TRUE(cast<BinaryOperator>(Add->clone())->hasNoUnsignedWrap());
-  EXPECT_TRUE(cast<BinaryOperator>(Add->clone())->hasNoSignedWrap());
-  EXPECT_TRUE(cast<BinaryOperator>(Sub->clone())->hasNoUnsignedWrap());
-  EXPECT_TRUE(cast<BinaryOperator>(Sub->clone())->hasNoSignedWrap());
-  EXPECT_TRUE(cast<BinaryOperator>(Mul->clone())->hasNoUnsignedWrap());
-  EXPECT_TRUE(cast<BinaryOperator>(Mul->clone())->hasNoSignedWrap());
+  AddClone = this->clone(Add);
+  SubClone = this->clone(Sub);
+  MulClone = this->clone(Mul);
+
+  EXPECT_TRUE(AddClone->hasNoUnsignedWrap());
+  EXPECT_TRUE(AddClone->hasNoSignedWrap());
+  EXPECT_TRUE(SubClone->hasNoUnsignedWrap());
+  EXPECT_TRUE(SubClone->hasNoSignedWrap());
+  EXPECT_TRUE(MulClone->hasNoUnsignedWrap());
+  EXPECT_TRUE(MulClone->hasNoSignedWrap());
+
+  eraseClones();
 
   Add->setHasNoUnsignedWrap(false);
   Sub->setHasNoUnsignedWrap(false);
   Mul->setHasNoUnsignedWrap(false);
 
-  EXPECT_FALSE(cast<BinaryOperator>(Add->clone())->hasNoUnsignedWrap());
-  EXPECT_TRUE(cast<BinaryOperator>(Add->clone())->hasNoSignedWrap());
-  EXPECT_FALSE(cast<BinaryOperator>(Sub->clone())->hasNoUnsignedWrap());
-  EXPECT_TRUE(cast<BinaryOperator>(Sub->clone())->hasNoSignedWrap());
-  EXPECT_FALSE(cast<BinaryOperator>(Mul->clone())->hasNoUnsignedWrap());
-  EXPECT_TRUE(cast<BinaryOperator>(Mul->clone())->hasNoSignedWrap());
+  AddClone = this->clone(Add);
+  SubClone = this->clone(Sub);
+  MulClone = this->clone(Mul);
+
+  EXPECT_FALSE(AddClone->hasNoUnsignedWrap());
+  EXPECT_TRUE(AddClone->hasNoSignedWrap());
+  EXPECT_FALSE(SubClone->hasNoUnsignedWrap());
+  EXPECT_TRUE(SubClone->hasNoSignedWrap());
+  EXPECT_FALSE(MulClone->hasNoUnsignedWrap());
+  EXPECT_TRUE(MulClone->hasNoSignedWrap());
 }
 
-TEST(CloneInstruction, Inbounds) {
-  LLVMContext context;
-  Value *V = new Argument(Type::getInt32PtrTy(context));
+TEST_F(CloneInstruction, Inbounds) {
+  V = new Argument(Type::getInt32PtrTy(context));
+
   Constant *Z = Constant::getNullValue(Type::getInt32Ty(context));
   std::vector<Value *> ops;
   ops.push_back(Z);
-  GetElementPtrInst *GEP = GetElementPtrInst::Create(V, ops.begin(), ops.end());
-  EXPECT_FALSE(cast<GetElementPtrInst>(GEP->clone())->isInBounds());
+  GetElementPtrInst *GEP = GetElementPtrInst::Create(V, ops);
+  EXPECT_FALSE(this->clone(GEP)->isInBounds());
 
   GEP->setIsInBounds();
-  EXPECT_TRUE(cast<GetElementPtrInst>(GEP->clone())->isInBounds());
+  EXPECT_TRUE(this->clone(GEP)->isInBounds());
 }
 
-TEST(CloneInstruction, Exact) {
-  LLVMContext context;
-  Value *V = new Argument(Type::getInt32Ty(context));
+TEST_F(CloneInstruction, Exact) {
+  V = new Argument(Type::getInt32Ty(context));
 
   BinaryOperator *SDiv = BinaryOperator::Create(Instruction::SDiv, V, V);
-  EXPECT_FALSE(cast<BinaryOperator>(SDiv->clone())->isExact());
+  EXPECT_FALSE(this->clone(SDiv)->isExact());
 
   SDiv->setIsExact(true);
-  EXPECT_TRUE(cast<BinaryOperator>(SDiv->clone())->isExact());
+  EXPECT_TRUE(this->clone(SDiv)->isExact());
+}
+
+TEST_F(CloneInstruction, Attributes) {
+  Type *ArgTy1[] = { Type::getInt32PtrTy(context) };
+  FunctionType *FT1 =  FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
+
+  Function *F1 = Function::Create(FT1, Function::ExternalLinkage);
+  BasicBlock *BB = BasicBlock::Create(context, "", F1);
+  IRBuilder<> Builder(BB);
+  Builder.CreateRetVoid();
+
+  Function *F2 = Function::Create(FT1, Function::ExternalLinkage);
+
+  Attribute::AttrKind AK[] = { Attribute::NoCapture };
+  AttributeSet AS = AttributeSet::get(context, 0, AK);
+  Argument *A = F1->arg_begin();
+  A->addAttr(AS);
+
+  SmallVector<ReturnInst*, 4> Returns;
+  ValueToValueMapTy VMap;
+  VMap[A] = UndefValue::get(A->getType());
+
+  CloneFunctionInto(F2, F1, VMap, false, Returns);
+  EXPECT_FALSE(F2->arg_begin()->hasNoCaptureAttr());
+
+  delete F1;
+  delete F2;
+}
+
 }