[rustc.git] / src / llvm / unittests / IR / IRBuilderTest.cpp

//===- llvm/unittest/IR/IRBuilderTest.cpp - IRBuilder tests ---------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/MDBuilder.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/NoFolder.h"
#include "gtest/gtest.h"

using namespace llvm;

namespace {

class IRBuilderTest : public testing::Test {
protected:
  virtual void SetUp() {
    M.reset(new Module("MyModule", Ctx));
    FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
                                          /*isVarArg=*/false);
    F = Function::Create(FTy, Function::ExternalLinkage, "", M.get());
    BB = BasicBlock::Create(Ctx, "", F);
    GV = new GlobalVariable(*M, Type::getFloatTy(Ctx), true,
                            GlobalValue::ExternalLinkage, nullptr);
  }

  virtual void TearDown() {
    BB = nullptr;
    M.reset();
  }

  LLVMContext Ctx;
  std::unique_ptr<Module> M;
  Function *F;
  BasicBlock *BB;
  GlobalVariable *GV;
};

TEST_F(IRBuilderTest, Lifetime) {
  IRBuilder<> Builder(BB);
  AllocaInst *Var1 = Builder.CreateAlloca(Builder.getInt8Ty());
  AllocaInst *Var2 = Builder.CreateAlloca(Builder.getInt32Ty());
  AllocaInst *Var3 = Builder.CreateAlloca(Builder.getInt8Ty(),
                                          Builder.getInt32(123));

  CallInst *Start1 = Builder.CreateLifetimeStart(Var1);
  CallInst *Start2 = Builder.CreateLifetimeStart(Var2);
  CallInst *Start3 = Builder.CreateLifetimeStart(Var3, Builder.getInt64(100));

  EXPECT_EQ(Start1->getArgOperand(0), Builder.getInt64(-1));
  EXPECT_EQ(Start2->getArgOperand(0), Builder.getInt64(-1));
  EXPECT_EQ(Start3->getArgOperand(0), Builder.getInt64(100));

  EXPECT_EQ(Start1->getArgOperand(1), Var1);
  EXPECT_NE(Start2->getArgOperand(1), Var2);
  EXPECT_EQ(Start3->getArgOperand(1), Var3);

  Value *End1 = Builder.CreateLifetimeEnd(Var1);
  Builder.CreateLifetimeEnd(Var2);
  Builder.CreateLifetimeEnd(Var3);

  IntrinsicInst *II_Start1 = dyn_cast<IntrinsicInst>(Start1);
  IntrinsicInst *II_End1 = dyn_cast<IntrinsicInst>(End1);
  ASSERT_TRUE(II_Start1 != nullptr);
  EXPECT_EQ(II_Start1->getIntrinsicID(), Intrinsic::lifetime_start);
  ASSERT_TRUE(II_End1 != nullptr);
  EXPECT_EQ(II_End1->getIntrinsicID(), Intrinsic::lifetime_end);
}

TEST_F(IRBuilderTest, CreateCondBr) {
  IRBuilder<> Builder(BB);
  BasicBlock *TBB = BasicBlock::Create(Ctx, "", F);
  BasicBlock *FBB = BasicBlock::Create(Ctx, "", F);

  BranchInst *BI = Builder.CreateCondBr(Builder.getTrue(), TBB, FBB);
  TerminatorInst *TI = BB->getTerminator();
  EXPECT_EQ(BI, TI);
  EXPECT_EQ(2u, TI->getNumSuccessors());
  EXPECT_EQ(TBB, TI->getSuccessor(0));
  EXPECT_EQ(FBB, TI->getSuccessor(1));

  BI->eraseFromParent();
  MDNode *Weights = MDBuilder(Ctx).createBranchWeights(42, 13);
  BI = Builder.CreateCondBr(Builder.getTrue(), TBB, FBB, Weights);
  TI = BB->getTerminator();
  EXPECT_EQ(BI, TI);
  EXPECT_EQ(2u, TI->getNumSuccessors());
  EXPECT_EQ(TBB, TI->getSuccessor(0));
  EXPECT_EQ(FBB, TI->getSuccessor(1));
  EXPECT_EQ(Weights, TI->getMetadata(LLVMContext::MD_prof));
}

TEST_F(IRBuilderTest, LandingPadName) {
  IRBuilder<> Builder(BB);
  LandingPadInst *LP = Builder.CreateLandingPad(Builder.getInt32Ty(),
                                                Builder.getInt32(0), 0, "LP");
  EXPECT_EQ(LP->getName(), "LP");
}

TEST_F(IRBuilderTest, DataLayout) {
  std::unique_ptr<Module> M(new Module("test", Ctx));
  M->setDataLayout("e-n32");
  EXPECT_TRUE(M->getDataLayout()->isLegalInteger(32));
  M->setDataLayout("e");
  EXPECT_FALSE(M->getDataLayout()->isLegalInteger(32));
}

TEST_F(IRBuilderTest, GetIntTy) {
  IRBuilder<> Builder(BB);
  IntegerType *Ty1 = Builder.getInt1Ty();
  EXPECT_EQ(Ty1, IntegerType::get(Ctx, 1));

  DataLayout* DL = new DataLayout(M.get());
  IntegerType *IntPtrTy = Builder.getIntPtrTy(DL);
  unsigned IntPtrBitSize =  DL->getPointerSizeInBits(0);
  EXPECT_EQ(IntPtrTy, IntegerType::get(Ctx, IntPtrBitSize));
  delete DL;
}

TEST_F(IRBuilderTest, FastMathFlags) {
  IRBuilder<> Builder(BB);
  Value *F;
  Instruction *FDiv, *FAdd;

  F = Builder.CreateLoad(GV);
  F = Builder.CreateFAdd(F, F);

  EXPECT_FALSE(Builder.getFastMathFlags().any());
  ASSERT_TRUE(isa<Instruction>(F));
  FAdd = cast<Instruction>(F);
  EXPECT_FALSE(FAdd->hasNoNaNs());

  FastMathFlags FMF;
  Builder.SetFastMathFlags(FMF);

  F = Builder.CreateFAdd(F, F);
  EXPECT_FALSE(Builder.getFastMathFlags().any());

  FMF.setUnsafeAlgebra();
  Builder.SetFastMathFlags(FMF);

  F = Builder.CreateFAdd(F, F);
  EXPECT_TRUE(Builder.getFastMathFlags().any());
  ASSERT_TRUE(isa<Instruction>(F));
  FAdd = cast<Instruction>(F);
  EXPECT_TRUE(FAdd->hasNoNaNs());

  // Now, try it with CreateBinOp
  F = Builder.CreateBinOp(Instruction::FAdd, F, F);
  EXPECT_TRUE(Builder.getFastMathFlags().any());
  ASSERT_TRUE(isa<Instruction>(F));
  FAdd = cast<Instruction>(F);
  EXPECT_TRUE(FAdd->hasNoNaNs());

  F = Builder.CreateFDiv(F, F);
  EXPECT_TRUE(Builder.getFastMathFlags().any());
  EXPECT_TRUE(Builder.getFastMathFlags().UnsafeAlgebra);
  ASSERT_TRUE(isa<Instruction>(F));
  FDiv = cast<Instruction>(F);
  EXPECT_TRUE(FDiv->hasAllowReciprocal());

  Builder.clearFastMathFlags();

  F = Builder.CreateFDiv(F, F);
  ASSERT_TRUE(isa<Instruction>(F));
  FDiv = cast<Instruction>(F);
  EXPECT_FALSE(FDiv->hasAllowReciprocal());

  FMF.clear();
  FMF.setAllowReciprocal();
  Builder.SetFastMathFlags(FMF);

  F = Builder.CreateFDiv(F, F);
  EXPECT_TRUE(Builder.getFastMathFlags().any());
  EXPECT_TRUE(Builder.getFastMathFlags().AllowReciprocal);
  ASSERT_TRUE(isa<Instruction>(F));
  FDiv = cast<Instruction>(F);
  EXPECT_TRUE(FDiv->hasAllowReciprocal());

  Builder.clearFastMathFlags();

  // To test a copy, make sure that a '0' and a '1' change state. 
  F = Builder.CreateFDiv(F, F);
  ASSERT_TRUE(isa<Instruction>(F));
  FDiv = cast<Instruction>(F);
  EXPECT_FALSE(FDiv->getFastMathFlags().any());
  FDiv->setHasAllowReciprocal(true);
  FAdd->setHasAllowReciprocal(false);
  FDiv->copyFastMathFlags(FAdd);
  EXPECT_TRUE(FDiv->hasNoNaNs());
  EXPECT_FALSE(FDiv->hasAllowReciprocal());

}

TEST_F(IRBuilderTest, WrapFlags) {
  IRBuilder<true, NoFolder> Builder(BB);

  // Test instructions.
  GlobalVariable *G = new GlobalVariable(*M, Builder.getInt32Ty(), true,
                                         GlobalValue::ExternalLinkage, nullptr);
  Value *V = Builder.CreateLoad(G);
  EXPECT_TRUE(
      cast<BinaryOperator>(Builder.CreateNSWAdd(V, V))->hasNoSignedWrap());
  EXPECT_TRUE(
      cast<BinaryOperator>(Builder.CreateNSWMul(V, V))->hasNoSignedWrap());
  EXPECT_TRUE(
      cast<BinaryOperator>(Builder.CreateNSWSub(V, V))->hasNoSignedWrap());
  EXPECT_TRUE(cast<BinaryOperator>(
                  Builder.CreateShl(V, V, "", /* NUW */ false, /* NSW */ true))
                  ->hasNoSignedWrap());

  EXPECT_TRUE(
      cast<BinaryOperator>(Builder.CreateNUWAdd(V, V))->hasNoUnsignedWrap());
  EXPECT_TRUE(
      cast<BinaryOperator>(Builder.CreateNUWMul(V, V))->hasNoUnsignedWrap());
  EXPECT_TRUE(
      cast<BinaryOperator>(Builder.CreateNUWSub(V, V))->hasNoUnsignedWrap());
  EXPECT_TRUE(cast<BinaryOperator>(
                  Builder.CreateShl(V, V, "", /* NUW */ true, /* NSW */ false))
                  ->hasNoUnsignedWrap());

  // Test operators created with constants.
  Constant *C = Builder.getInt32(42);
  EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWAdd(C, C))
                  ->hasNoSignedWrap());
  EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWSub(C, C))
                  ->hasNoSignedWrap());
  EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWMul(C, C))
                  ->hasNoSignedWrap());
  EXPECT_TRUE(cast<OverflowingBinaryOperator>(
                  Builder.CreateShl(C, C, "", /* NUW */ false, /* NSW */ true))
                  ->hasNoSignedWrap());

  EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWAdd(C, C))
                  ->hasNoUnsignedWrap());
  EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWSub(C, C))
                  ->hasNoUnsignedWrap());
  EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWMul(C, C))
                  ->hasNoUnsignedWrap());
  EXPECT_TRUE(cast<OverflowingBinaryOperator>(
                  Builder.CreateShl(C, C, "", /* NUW */ true, /* NSW */ false))
                  ->hasNoUnsignedWrap());
}

TEST_F(IRBuilderTest, RAIIHelpersTest) {
  IRBuilder<> Builder(BB);
  EXPECT_FALSE(Builder.getFastMathFlags().allowReciprocal());
  MDBuilder MDB(M->getContext());

  MDNode *FPMathA = MDB.createFPMath(0.01f);
  MDNode *FPMathB = MDB.createFPMath(0.1f);

  Builder.SetDefaultFPMathTag(FPMathA);

  {
    IRBuilder<>::FastMathFlagGuard Guard(Builder);
    FastMathFlags FMF;
    FMF.setAllowReciprocal();
    Builder.SetFastMathFlags(FMF);
    Builder.SetDefaultFPMathTag(FPMathB);
    EXPECT_TRUE(Builder.getFastMathFlags().allowReciprocal());
    EXPECT_EQ(FPMathB, Builder.getDefaultFPMathTag());
  }

  EXPECT_FALSE(Builder.getFastMathFlags().allowReciprocal());
  EXPECT_EQ(FPMathA, Builder.getDefaultFPMathTag());

  Value *F = Builder.CreateLoad(GV);

  {
    IRBuilder<>::InsertPointGuard Guard(Builder);
    Builder.SetInsertPoint(cast<Instruction>(F));
    EXPECT_EQ(F, Builder.GetInsertPoint());
  }

  EXPECT_EQ(BB->end(), Builder.GetInsertPoint());
  EXPECT_EQ(BB, Builder.GetInsertBlock());
}


}
Commit	Line	Data
970d7e83	1	//===- llvm/unittest/IR/IRBuilderTest.cpp - IRBuilder tests ---------------===//
223e47cc LB	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
970d7e83	10	#include "llvm/IR/IRBuilder.h"
970d7e83 LB	11	#include "llvm/IR/BasicBlock.h"
	12	#include "llvm/IR/DataLayout.h"
	13	#include "llvm/IR/Function.h"
	14	#include "llvm/IR/IntrinsicInst.h"
	15	#include "llvm/IR/LLVMContext.h"
	16	#include "llvm/IR/MDBuilder.h"
	17	#include "llvm/IR/Module.h"
1a4d82fc	18	#include "llvm/IR/NoFolder.h"
223e47cc LB	19	#include "gtest/gtest.h"
	20
	21	using namespace llvm;
	22
	23	namespace {
	24
	25	class IRBuilderTest : public testing::Test {
	26	protected:
	27	virtual void SetUp() {
1a4d82fc JJ	28	M.reset(new Module("MyModule", Ctx));
1a4d82fc JJ	29	FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
223e47cc LB	30	/isVarArg=/false);
223e47cc LB	31	F = Function::Create(FTy, Function::ExternalLinkage, "", M.get());
1a4d82fc JJ	32	BB = BasicBlock::Create(Ctx, "", F);
	33	GV = new GlobalVariable(*M, Type::getFloatTy(Ctx), true,
	34	GlobalValue::ExternalLinkage, nullptr);
223e47cc LB	35	}
	36
	37	virtual void TearDown() {
1a4d82fc	38	BB = nullptr;
223e47cc LB	39	M.reset();
	40	}
	41
1a4d82fc JJ	42	LLVMContext Ctx;
1a4d82fc JJ	43	std::unique_ptr<Module> M;
223e47cc LB	44	Function *F;
223e47cc LB	45	BasicBlock *BB;
970d7e83	46	GlobalVariable *GV;
223e47cc LB	47	};
	48
	49	TEST_F(IRBuilderTest, Lifetime) {
	50	IRBuilder<> Builder(BB);
	51	AllocaInst *Var1 = Builder.CreateAlloca(Builder.getInt8Ty());
	52	AllocaInst *Var2 = Builder.CreateAlloca(Builder.getInt32Ty());
	53	AllocaInst *Var3 = Builder.CreateAlloca(Builder.getInt8Ty(),
	54	Builder.getInt32(123));
	55
	56	CallInst *Start1 = Builder.CreateLifetimeStart(Var1);
	57	CallInst *Start2 = Builder.CreateLifetimeStart(Var2);
	58	CallInst *Start3 = Builder.CreateLifetimeStart(Var3, Builder.getInt64(100));
	59
	60	EXPECT_EQ(Start1->getArgOperand(0), Builder.getInt64(-1));
	61	EXPECT_EQ(Start2->getArgOperand(0), Builder.getInt64(-1));
	62	EXPECT_EQ(Start3->getArgOperand(0), Builder.getInt64(100));
	63
	64	EXPECT_EQ(Start1->getArgOperand(1), Var1);
	65	EXPECT_NE(Start2->getArgOperand(1), Var2);
	66	EXPECT_EQ(Start3->getArgOperand(1), Var3);
	67
	68	Value *End1 = Builder.CreateLifetimeEnd(Var1);
	69	Builder.CreateLifetimeEnd(Var2);
	70	Builder.CreateLifetimeEnd(Var3);
	71
	72	IntrinsicInst *II_Start1 = dyn_cast<IntrinsicInst>(Start1);
	73	IntrinsicInst *II_End1 = dyn_cast<IntrinsicInst>(End1);
1a4d82fc	74	ASSERT_TRUE(II_Start1 != nullptr);
223e47cc	75	EXPECT_EQ(II_Start1->getIntrinsicID(), Intrinsic::lifetime_start);
1a4d82fc	76	ASSERT_TRUE(II_End1 != nullptr);
223e47cc LB	77	EXPECT_EQ(II_End1->getIntrinsicID(), Intrinsic::lifetime_end);
	78	}
	79
	80	TEST_F(IRBuilderTest, CreateCondBr) {
	81	IRBuilder<> Builder(BB);
1a4d82fc JJ	82	BasicBlock *TBB = BasicBlock::Create(Ctx, "", F);
1a4d82fc JJ	83	BasicBlock *FBB = BasicBlock::Create(Ctx, "", F);
223e47cc LB	84
	85	BranchInst *BI = Builder.CreateCondBr(Builder.getTrue(), TBB, FBB);
	86	TerminatorInst *TI = BB->getTerminator();
	87	EXPECT_EQ(BI, TI);
	88	EXPECT_EQ(2u, TI->getNumSuccessors());
	89	EXPECT_EQ(TBB, TI->getSuccessor(0));
	90	EXPECT_EQ(FBB, TI->getSuccessor(1));
	91
	92	BI->eraseFromParent();
1a4d82fc	93	MDNode *Weights = MDBuilder(Ctx).createBranchWeights(42, 13);
223e47cc LB	94	BI = Builder.CreateCondBr(Builder.getTrue(), TBB, FBB, Weights);
	95	TI = BB->getTerminator();
	96	EXPECT_EQ(BI, TI);
	97	EXPECT_EQ(2u, TI->getNumSuccessors());
	98	EXPECT_EQ(TBB, TI->getSuccessor(0));
	99	EXPECT_EQ(FBB, TI->getSuccessor(1));
	100	EXPECT_EQ(Weights, TI->getMetadata(LLVMContext::MD_prof));
	101	}
	102
970d7e83 LB	103	TEST_F(IRBuilderTest, LandingPadName) {
	104	IRBuilder<> Builder(BB);
	105	LandingPadInst *LP = Builder.CreateLandingPad(Builder.getInt32Ty(),
	106	Builder.getInt32(0), 0, "LP");
	107	EXPECT_EQ(LP->getName(), "LP");
	108	}
	109
1a4d82fc JJ	110	TEST_F(IRBuilderTest, DataLayout) {
	111	std::unique_ptr<Module> M(new Module("test", Ctx));
	112	M->setDataLayout("e-n32");
	113	EXPECT_TRUE(M->getDataLayout()->isLegalInteger(32));
	114	M->setDataLayout("e");
	115	EXPECT_FALSE(M->getDataLayout()->isLegalInteger(32));
	116	}
	117
970d7e83 LB	118	TEST_F(IRBuilderTest, GetIntTy) {
	119	IRBuilder<> Builder(BB);
	120	IntegerType *Ty1 = Builder.getInt1Ty();
1a4d82fc	121	EXPECT_EQ(Ty1, IntegerType::get(Ctx, 1));
970d7e83 LB	122
	123	DataLayout* DL = new DataLayout(M.get());
	124	IntegerType *IntPtrTy = Builder.getIntPtrTy(DL);
	125	unsigned IntPtrBitSize = DL->getPointerSizeInBits(0);
1a4d82fc	126	EXPECT_EQ(IntPtrTy, IntegerType::get(Ctx, IntPtrBitSize));
970d7e83 LB	127	delete DL;
	128	}
	129
	130	TEST_F(IRBuilderTest, FastMathFlags) {
	131	IRBuilder<> Builder(BB);
	132	Value *F;
	133	Instruction FDiv, FAdd;
	134
	135	F = Builder.CreateLoad(GV);
	136	F = Builder.CreateFAdd(F, F);
	137
	138	EXPECT_FALSE(Builder.getFastMathFlags().any());
	139	ASSERT_TRUE(isa<Instruction>(F));
	140	FAdd = cast<Instruction>(F);
	141	EXPECT_FALSE(FAdd->hasNoNaNs());
	142
	143	FastMathFlags FMF;
	144	Builder.SetFastMathFlags(FMF);
	145
	146	F = Builder.CreateFAdd(F, F);
	147	EXPECT_FALSE(Builder.getFastMathFlags().any());
	148
	149	FMF.setUnsafeAlgebra();
	150	Builder.SetFastMathFlags(FMF);
	151
	152	F = Builder.CreateFAdd(F, F);
	153	EXPECT_TRUE(Builder.getFastMathFlags().any());
	154	ASSERT_TRUE(isa<Instruction>(F));
	155	FAdd = cast<Instruction>(F);
	156	EXPECT_TRUE(FAdd->hasNoNaNs());
	157
1a4d82fc JJ	158	// Now, try it with CreateBinOp
	159	F = Builder.CreateBinOp(Instruction::FAdd, F, F);
	160	EXPECT_TRUE(Builder.getFastMathFlags().any());
	161	ASSERT_TRUE(isa<Instruction>(F));
	162	FAdd = cast<Instruction>(F);
	163	EXPECT_TRUE(FAdd->hasNoNaNs());
	164
970d7e83 LB	165	F = Builder.CreateFDiv(F, F);
	166	EXPECT_TRUE(Builder.getFastMathFlags().any());
	167	EXPECT_TRUE(Builder.getFastMathFlags().UnsafeAlgebra);
	168	ASSERT_TRUE(isa<Instruction>(F));
	169	FDiv = cast<Instruction>(F);
	170	EXPECT_TRUE(FDiv->hasAllowReciprocal());
	171
	172	Builder.clearFastMathFlags();
	173
	174	F = Builder.CreateFDiv(F, F);
	175	ASSERT_TRUE(isa<Instruction>(F));
	176	FDiv = cast<Instruction>(F);
	177	EXPECT_FALSE(FDiv->hasAllowReciprocal());
	178
	179	FMF.clear();
	180	FMF.setAllowReciprocal();
	181	Builder.SetFastMathFlags(FMF);
	182
	183	F = Builder.CreateFDiv(F, F);
	184	EXPECT_TRUE(Builder.getFastMathFlags().any());
	185	EXPECT_TRUE(Builder.getFastMathFlags().AllowReciprocal);
	186	ASSERT_TRUE(isa<Instruction>(F));
	187	FDiv = cast<Instruction>(F);
	188	EXPECT_TRUE(FDiv->hasAllowReciprocal());
	189
	190	Builder.clearFastMathFlags();
	191
1a4d82fc	192	// To test a copy, make sure that a '0' and a '1' change state.
970d7e83 LB	193	F = Builder.CreateFDiv(F, F);
	194	ASSERT_TRUE(isa<Instruction>(F));
	195	FDiv = cast<Instruction>(F);
	196	EXPECT_FALSE(FDiv->getFastMathFlags().any());
1a4d82fc JJ	197	FDiv->setHasAllowReciprocal(true);
1a4d82fc JJ	198	FAdd->setHasAllowReciprocal(false);
970d7e83 LB	199	FDiv->copyFastMathFlags(FAdd);
970d7e83 LB	200	EXPECT_TRUE(FDiv->hasNoNaNs());
1a4d82fc JJ	201	EXPECT_FALSE(FDiv->hasAllowReciprocal());
	202
	203	}
970d7e83	204
1a4d82fc JJ	205	TEST_F(IRBuilderTest, WrapFlags) {
	206	IRBuilder<true, NoFolder> Builder(BB);
	207
	208	// Test instructions.
	209	GlobalVariable G = new GlobalVariable(M, Builder.getInt32Ty(), true,
	210	GlobalValue::ExternalLinkage, nullptr);
	211	Value *V = Builder.CreateLoad(G);
	212	EXPECT_TRUE(
	213	cast<BinaryOperator>(Builder.CreateNSWAdd(V, V))->hasNoSignedWrap());
	214	EXPECT_TRUE(
	215	cast<BinaryOperator>(Builder.CreateNSWMul(V, V))->hasNoSignedWrap());
	216	EXPECT_TRUE(
	217	cast<BinaryOperator>(Builder.CreateNSWSub(V, V))->hasNoSignedWrap());
	218	EXPECT_TRUE(cast<BinaryOperator>(
	219	Builder.CreateShl(V, V, "", /* NUW / false, / NSW */ true))
	220	->hasNoSignedWrap());
	221
	222	EXPECT_TRUE(
	223	cast<BinaryOperator>(Builder.CreateNUWAdd(V, V))->hasNoUnsignedWrap());
	224	EXPECT_TRUE(
	225	cast<BinaryOperator>(Builder.CreateNUWMul(V, V))->hasNoUnsignedWrap());
	226	EXPECT_TRUE(
	227	cast<BinaryOperator>(Builder.CreateNUWSub(V, V))->hasNoUnsignedWrap());
	228	EXPECT_TRUE(cast<BinaryOperator>(
	229	Builder.CreateShl(V, V, "", /* NUW / true, / NSW */ false))
	230	->hasNoUnsignedWrap());
	231
	232	// Test operators created with constants.
	233	Constant *C = Builder.getInt32(42);
	234	EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWAdd(C, C))
	235	->hasNoSignedWrap());
	236	EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWSub(C, C))
	237	->hasNoSignedWrap());
	238	EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWMul(C, C))
	239	->hasNoSignedWrap());
	240	EXPECT_TRUE(cast<OverflowingBinaryOperator>(
	241	Builder.CreateShl(C, C, "", /* NUW / false, / NSW */ true))
	242	->hasNoSignedWrap());
	243
	244	EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWAdd(C, C))
	245	->hasNoUnsignedWrap());
	246	EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWSub(C, C))
	247	->hasNoUnsignedWrap());
	248	EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWMul(C, C))
	249	->hasNoUnsignedWrap());
	250	EXPECT_TRUE(cast<OverflowingBinaryOperator>(
	251	Builder.CreateShl(C, C, "", /* NUW / true, / NSW */ false))
	252	->hasNoUnsignedWrap());
970d7e83 LB	253	}
970d7e83 LB	254
1a4d82fc JJ	255	TEST_F(IRBuilderTest, RAIIHelpersTest) {
	256	IRBuilder<> Builder(BB);
	257	EXPECT_FALSE(Builder.getFastMathFlags().allowReciprocal());
	258	MDBuilder MDB(M->getContext());
	259
	260	MDNode *FPMathA = MDB.createFPMath(0.01f);
	261	MDNode *FPMathB = MDB.createFPMath(0.1f);
	262
	263	Builder.SetDefaultFPMathTag(FPMathA);
	264
	265	{
	266	IRBuilder<>::FastMathFlagGuard Guard(Builder);
	267	FastMathFlags FMF;
	268	FMF.setAllowReciprocal();
	269	Builder.SetFastMathFlags(FMF);
	270	Builder.SetDefaultFPMathTag(FPMathB);
	271	EXPECT_TRUE(Builder.getFastMathFlags().allowReciprocal());
	272	EXPECT_EQ(FPMathB, Builder.getDefaultFPMathTag());
	273	}
	274
	275	EXPECT_FALSE(Builder.getFastMathFlags().allowReciprocal());
	276	EXPECT_EQ(FPMathA, Builder.getDefaultFPMathTag());
	277
	278	Value *F = Builder.CreateLoad(GV);
	279
	280	{
	281	IRBuilder<>::InsertPointGuard Guard(Builder);
	282	Builder.SetInsertPoint(cast<Instruction>(F));
	283	EXPECT_EQ(F, Builder.GetInsertPoint());
	284	}
	285
	286	EXPECT_EQ(BB->end(), Builder.GetInsertPoint());
	287	EXPECT_EQ(BB, Builder.GetInsertBlock());
	288	}
	289
	290
223e47cc	291	}