From: Chandler Carruth Date: Tue, 4 Mar 2014 12:05:47 +0000 (+0000) Subject: [Modules] Move the NoFolder into the IR library as it creates X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=ff956e7568a4d88762cd038497d97498c680e70c;p=oota-llvm.git [Modules] Move the NoFolder into the IR library as it creates instructions. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@202834 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/IR/NoFolder.h b/include/llvm/IR/NoFolder.h new file mode 100644 index 00000000000..a9cdfc36fb4 --- /dev/null +++ b/include/llvm/IR/NoFolder.h @@ -0,0 +1,298 @@ +//===- NoFolder.h - Constant folding helper ---------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the NoFolder class, a helper for IRBuilder. It provides +// IRBuilder with a set of methods for creating unfolded constants. This is +// useful for learners trying to understand how LLVM IR works, and who don't +// want details to be hidden by the constant folder. For general constant +// creation and folding, use ConstantExpr and the routines in +// llvm/Analysis/ConstantFolding.h. +// +// Note: since it is not actually possible to create unfolded constants, this +// class returns instructions rather than constants. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_IR_NOFOLDER_H +#define LLVM_IR_NOFOLDER_H + +#include "llvm/ADT/ArrayRef.h" +#include "llvm/IR/Constants.h" +#include "llvm/IR/Instructions.h" + +namespace llvm { + +/// NoFolder - Create "constants" (actually, instructions) with no folding. +class NoFolder { +public: + explicit NoFolder() {} + + //===--------------------------------------------------------------------===// + // Binary Operators + //===--------------------------------------------------------------------===// + + Instruction *CreateAdd(Constant *LHS, Constant *RHS, + bool HasNUW = false, bool HasNSW = false) const { + BinaryOperator *BO = BinaryOperator::CreateAdd(LHS, RHS); + if (HasNUW) BO->setHasNoUnsignedWrap(); + if (HasNSW) BO->setHasNoSignedWrap(); + return BO; + } + Instruction *CreateNSWAdd(Constant *LHS, Constant *RHS) const { + return BinaryOperator::CreateNSWAdd(LHS, RHS); + } + Instruction *CreateNUWAdd(Constant *LHS, Constant *RHS) const { + return BinaryOperator::CreateNUWAdd(LHS, RHS); + } + Instruction *CreateFAdd(Constant *LHS, Constant *RHS) const { + return BinaryOperator::CreateFAdd(LHS, RHS); + } + Instruction *CreateSub(Constant *LHS, Constant *RHS, + bool HasNUW = false, bool HasNSW = false) const { + BinaryOperator *BO = BinaryOperator::CreateSub(LHS, RHS); + if (HasNUW) BO->setHasNoUnsignedWrap(); + if (HasNSW) BO->setHasNoSignedWrap(); + return BO; + } + Instruction *CreateNSWSub(Constant *LHS, Constant *RHS) const { + return BinaryOperator::CreateNSWSub(LHS, RHS); + } + Instruction *CreateNUWSub(Constant *LHS, Constant *RHS) const { + return BinaryOperator::CreateNUWSub(LHS, RHS); + } + Instruction *CreateFSub(Constant *LHS, Constant *RHS) const { + return BinaryOperator::CreateFSub(LHS, RHS); + } + Instruction *CreateMul(Constant *LHS, Constant *RHS, + bool HasNUW = false, bool HasNSW = false) const { + BinaryOperator *BO = BinaryOperator::CreateMul(LHS, RHS); + if (HasNUW) BO->setHasNoUnsignedWrap(); + if (HasNSW) BO->setHasNoSignedWrap(); + return BO; + } + Instruction *CreateNSWMul(Constant *LHS, Constant *RHS) const { + return BinaryOperator::CreateNSWMul(LHS, RHS); + } + Instruction *CreateNUWMul(Constant *LHS, Constant *RHS) const { + return BinaryOperator::CreateNUWMul(LHS, RHS); + } + Instruction *CreateFMul(Constant *LHS, Constant *RHS) const { + return BinaryOperator::CreateFMul(LHS, RHS); + } + Instruction *CreateUDiv(Constant *LHS, Constant *RHS, + bool isExact = false) const { + if (!isExact) + return BinaryOperator::CreateUDiv(LHS, RHS); + return BinaryOperator::CreateExactUDiv(LHS, RHS); + } + Instruction *CreateExactUDiv(Constant *LHS, Constant *RHS) const { + return BinaryOperator::CreateExactUDiv(LHS, RHS); + } + Instruction *CreateSDiv(Constant *LHS, Constant *RHS, + bool isExact = false) const { + if (!isExact) + return BinaryOperator::CreateSDiv(LHS, RHS); + return BinaryOperator::CreateExactSDiv(LHS, RHS); + } + Instruction *CreateExactSDiv(Constant *LHS, Constant *RHS) const { + return BinaryOperator::CreateExactSDiv(LHS, RHS); + } + Instruction *CreateFDiv(Constant *LHS, Constant *RHS) const { + return BinaryOperator::CreateFDiv(LHS, RHS); + } + Instruction *CreateURem(Constant *LHS, Constant *RHS) const { + return BinaryOperator::CreateURem(LHS, RHS); + } + Instruction *CreateSRem(Constant *LHS, Constant *RHS) const { + return BinaryOperator::CreateSRem(LHS, RHS); + } + Instruction *CreateFRem(Constant *LHS, Constant *RHS) const { + return BinaryOperator::CreateFRem(LHS, RHS); + } + Instruction *CreateShl(Constant *LHS, Constant *RHS, bool HasNUW = false, + bool HasNSW = false) const { + BinaryOperator *BO = BinaryOperator::CreateShl(LHS, RHS); + if (HasNUW) BO->setHasNoUnsignedWrap(); + if (HasNSW) BO->setHasNoSignedWrap(); + return BO; + } + Instruction *CreateLShr(Constant *LHS, Constant *RHS, + bool isExact = false) const { + if (!isExact) + return BinaryOperator::CreateLShr(LHS, RHS); + return BinaryOperator::CreateExactLShr(LHS, RHS); + } + Instruction *CreateAShr(Constant *LHS, Constant *RHS, + bool isExact = false) const { + if (!isExact) + return BinaryOperator::CreateAShr(LHS, RHS); + return BinaryOperator::CreateExactAShr(LHS, RHS); + } + Instruction *CreateAnd(Constant *LHS, Constant *RHS) const { + return BinaryOperator::CreateAnd(LHS, RHS); + } + Instruction *CreateOr(Constant *LHS, Constant *RHS) const { + return BinaryOperator::CreateOr(LHS, RHS); + } + Instruction *CreateXor(Constant *LHS, Constant *RHS) const { + return BinaryOperator::CreateXor(LHS, RHS); + } + + Instruction *CreateBinOp(Instruction::BinaryOps Opc, + Constant *LHS, Constant *RHS) const { + return BinaryOperator::Create(Opc, LHS, RHS); + } + + //===--------------------------------------------------------------------===// + // Unary Operators + //===--------------------------------------------------------------------===// + + Instruction *CreateNeg(Constant *C, + bool HasNUW = false, bool HasNSW = false) const { + BinaryOperator *BO = BinaryOperator::CreateNeg(C); + if (HasNUW) BO->setHasNoUnsignedWrap(); + if (HasNSW) BO->setHasNoSignedWrap(); + return BO; + } + Instruction *CreateNSWNeg(Constant *C) const { + return BinaryOperator::CreateNSWNeg(C); + } + Instruction *CreateNUWNeg(Constant *C) const { + return BinaryOperator::CreateNUWNeg(C); + } + Instruction *CreateFNeg(Constant *C) const { + return BinaryOperator::CreateFNeg(C); + } + Instruction *CreateNot(Constant *C) const { + return BinaryOperator::CreateNot(C); + } + + //===--------------------------------------------------------------------===// + // Memory Instructions + //===--------------------------------------------------------------------===// + + Constant *CreateGetElementPtr(Constant *C, + ArrayRef IdxList) const { + return ConstantExpr::getGetElementPtr(C, IdxList); + } + Constant *CreateGetElementPtr(Constant *C, Constant *Idx) const { + // This form of the function only exists to avoid ambiguous overload + // warnings about whether to convert Idx to ArrayRef or + // ArrayRef. + return ConstantExpr::getGetElementPtr(C, Idx); + } + Instruction *CreateGetElementPtr(Constant *C, + ArrayRef IdxList) const { + return GetElementPtrInst::Create(C, IdxList); + } + + Constant *CreateInBoundsGetElementPtr(Constant *C, + ArrayRef IdxList) const { + return ConstantExpr::getInBoundsGetElementPtr(C, IdxList); + } + Constant *CreateInBoundsGetElementPtr(Constant *C, Constant *Idx) const { + // This form of the function only exists to avoid ambiguous overload + // warnings about whether to convert Idx to ArrayRef or + // ArrayRef. + return ConstantExpr::getInBoundsGetElementPtr(C, Idx); + } + Instruction *CreateInBoundsGetElementPtr(Constant *C, + ArrayRef IdxList) const { + return GetElementPtrInst::CreateInBounds(C, IdxList); + } + + //===--------------------------------------------------------------------===// + // Cast/Conversion Operators + //===--------------------------------------------------------------------===// + + Instruction *CreateCast(Instruction::CastOps Op, Constant *C, + Type *DestTy) const { + return CastInst::Create(Op, C, DestTy); + } + Instruction *CreatePointerCast(Constant *C, Type *DestTy) const { + return CastInst::CreatePointerCast(C, DestTy); + } + Instruction *CreateIntCast(Constant *C, Type *DestTy, + bool isSigned) const { + return CastInst::CreateIntegerCast(C, DestTy, isSigned); + } + Instruction *CreateFPCast(Constant *C, Type *DestTy) const { + return CastInst::CreateFPCast(C, DestTy); + } + + Instruction *CreateBitCast(Constant *C, Type *DestTy) const { + return CreateCast(Instruction::BitCast, C, DestTy); + } + Instruction *CreateIntToPtr(Constant *C, Type *DestTy) const { + return CreateCast(Instruction::IntToPtr, C, DestTy); + } + Instruction *CreatePtrToInt(Constant *C, Type *DestTy) const { + return CreateCast(Instruction::PtrToInt, C, DestTy); + } + Instruction *CreateZExtOrBitCast(Constant *C, Type *DestTy) const { + return CastInst::CreateZExtOrBitCast(C, DestTy); + } + Instruction *CreateSExtOrBitCast(Constant *C, Type *DestTy) const { + return CastInst::CreateSExtOrBitCast(C, DestTy); + } + + Instruction *CreateTruncOrBitCast(Constant *C, Type *DestTy) const { + return CastInst::CreateTruncOrBitCast(C, DestTy); + } + + //===--------------------------------------------------------------------===// + // Compare Instructions + //===--------------------------------------------------------------------===// + + Instruction *CreateICmp(CmpInst::Predicate P, + Constant *LHS, Constant *RHS) const { + return new ICmpInst(P, LHS, RHS); + } + Instruction *CreateFCmp(CmpInst::Predicate P, + Constant *LHS, Constant *RHS) const { + return new FCmpInst(P, LHS, RHS); + } + + //===--------------------------------------------------------------------===// + // Other Instructions + //===--------------------------------------------------------------------===// + + Instruction *CreateSelect(Constant *C, + Constant *True, Constant *False) const { + return SelectInst::Create(C, True, False); + } + + Instruction *CreateExtractElement(Constant *Vec, Constant *Idx) const { + return ExtractElementInst::Create(Vec, Idx); + } + + Instruction *CreateInsertElement(Constant *Vec, Constant *NewElt, + Constant *Idx) const { + return InsertElementInst::Create(Vec, NewElt, Idx); + } + + Instruction *CreateShuffleVector(Constant *V1, Constant *V2, + Constant *Mask) const { + return new ShuffleVectorInst(V1, V2, Mask); + } + + Instruction *CreateExtractValue(Constant *Agg, + ArrayRef IdxList) const { + return ExtractValueInst::Create(Agg, IdxList); + } + + Instruction *CreateInsertValue(Constant *Agg, Constant *Val, + ArrayRef IdxList) const { + return InsertValueInst::Create(Agg, Val, IdxList); + } +}; + +} + +#endif diff --git a/include/llvm/Support/NoFolder.h b/include/llvm/Support/NoFolder.h deleted file mode 100644 index ecfbbaa7824..00000000000 --- a/include/llvm/Support/NoFolder.h +++ /dev/null @@ -1,298 +0,0 @@ -//======-- llvm/Support/NoFolder.h - Constant folding helper -*- C++ -*-======// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file defines the NoFolder class, a helper for IRBuilder. It provides -// IRBuilder with a set of methods for creating unfolded constants. This is -// useful for learners trying to understand how LLVM IR works, and who don't -// want details to be hidden by the constant folder. For general constant -// creation and folding, use ConstantExpr and the routines in -// llvm/Analysis/ConstantFolding.h. -// -// Note: since it is not actually possible to create unfolded constants, this -// class returns instructions rather than constants. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_SUPPORT_NOFOLDER_H -#define LLVM_SUPPORT_NOFOLDER_H - -#include "llvm/ADT/ArrayRef.h" -#include "llvm/IR/Constants.h" -#include "llvm/IR/Instructions.h" - -namespace llvm { - -/// NoFolder - Create "constants" (actually, instructions) with no folding. -class NoFolder { -public: - explicit NoFolder() {} - - //===--------------------------------------------------------------------===// - // Binary Operators - //===--------------------------------------------------------------------===// - - Instruction *CreateAdd(Constant *LHS, Constant *RHS, - bool HasNUW = false, bool HasNSW = false) const { - BinaryOperator *BO = BinaryOperator::CreateAdd(LHS, RHS); - if (HasNUW) BO->setHasNoUnsignedWrap(); - if (HasNSW) BO->setHasNoSignedWrap(); - return BO; - } - Instruction *CreateNSWAdd(Constant *LHS, Constant *RHS) const { - return BinaryOperator::CreateNSWAdd(LHS, RHS); - } - Instruction *CreateNUWAdd(Constant *LHS, Constant *RHS) const { - return BinaryOperator::CreateNUWAdd(LHS, RHS); - } - Instruction *CreateFAdd(Constant *LHS, Constant *RHS) const { - return BinaryOperator::CreateFAdd(LHS, RHS); - } - Instruction *CreateSub(Constant *LHS, Constant *RHS, - bool HasNUW = false, bool HasNSW = false) const { - BinaryOperator *BO = BinaryOperator::CreateSub(LHS, RHS); - if (HasNUW) BO->setHasNoUnsignedWrap(); - if (HasNSW) BO->setHasNoSignedWrap(); - return BO; - } - Instruction *CreateNSWSub(Constant *LHS, Constant *RHS) const { - return BinaryOperator::CreateNSWSub(LHS, RHS); - } - Instruction *CreateNUWSub(Constant *LHS, Constant *RHS) const { - return BinaryOperator::CreateNUWSub(LHS, RHS); - } - Instruction *CreateFSub(Constant *LHS, Constant *RHS) const { - return BinaryOperator::CreateFSub(LHS, RHS); - } - Instruction *CreateMul(Constant *LHS, Constant *RHS, - bool HasNUW = false, bool HasNSW = false) const { - BinaryOperator *BO = BinaryOperator::CreateMul(LHS, RHS); - if (HasNUW) BO->setHasNoUnsignedWrap(); - if (HasNSW) BO->setHasNoSignedWrap(); - return BO; - } - Instruction *CreateNSWMul(Constant *LHS, Constant *RHS) const { - return BinaryOperator::CreateNSWMul(LHS, RHS); - } - Instruction *CreateNUWMul(Constant *LHS, Constant *RHS) const { - return BinaryOperator::CreateNUWMul(LHS, RHS); - } - Instruction *CreateFMul(Constant *LHS, Constant *RHS) const { - return BinaryOperator::CreateFMul(LHS, RHS); - } - Instruction *CreateUDiv(Constant *LHS, Constant *RHS, - bool isExact = false) const { - if (!isExact) - return BinaryOperator::CreateUDiv(LHS, RHS); - return BinaryOperator::CreateExactUDiv(LHS, RHS); - } - Instruction *CreateExactUDiv(Constant *LHS, Constant *RHS) const { - return BinaryOperator::CreateExactUDiv(LHS, RHS); - } - Instruction *CreateSDiv(Constant *LHS, Constant *RHS, - bool isExact = false) const { - if (!isExact) - return BinaryOperator::CreateSDiv(LHS, RHS); - return BinaryOperator::CreateExactSDiv(LHS, RHS); - } - Instruction *CreateExactSDiv(Constant *LHS, Constant *RHS) const { - return BinaryOperator::CreateExactSDiv(LHS, RHS); - } - Instruction *CreateFDiv(Constant *LHS, Constant *RHS) const { - return BinaryOperator::CreateFDiv(LHS, RHS); - } - Instruction *CreateURem(Constant *LHS, Constant *RHS) const { - return BinaryOperator::CreateURem(LHS, RHS); - } - Instruction *CreateSRem(Constant *LHS, Constant *RHS) const { - return BinaryOperator::CreateSRem(LHS, RHS); - } - Instruction *CreateFRem(Constant *LHS, Constant *RHS) const { - return BinaryOperator::CreateFRem(LHS, RHS); - } - Instruction *CreateShl(Constant *LHS, Constant *RHS, bool HasNUW = false, - bool HasNSW = false) const { - BinaryOperator *BO = BinaryOperator::CreateShl(LHS, RHS); - if (HasNUW) BO->setHasNoUnsignedWrap(); - if (HasNSW) BO->setHasNoSignedWrap(); - return BO; - } - Instruction *CreateLShr(Constant *LHS, Constant *RHS, - bool isExact = false) const { - if (!isExact) - return BinaryOperator::CreateLShr(LHS, RHS); - return BinaryOperator::CreateExactLShr(LHS, RHS); - } - Instruction *CreateAShr(Constant *LHS, Constant *RHS, - bool isExact = false) const { - if (!isExact) - return BinaryOperator::CreateAShr(LHS, RHS); - return BinaryOperator::CreateExactAShr(LHS, RHS); - } - Instruction *CreateAnd(Constant *LHS, Constant *RHS) const { - return BinaryOperator::CreateAnd(LHS, RHS); - } - Instruction *CreateOr(Constant *LHS, Constant *RHS) const { - return BinaryOperator::CreateOr(LHS, RHS); - } - Instruction *CreateXor(Constant *LHS, Constant *RHS) const { - return BinaryOperator::CreateXor(LHS, RHS); - } - - Instruction *CreateBinOp(Instruction::BinaryOps Opc, - Constant *LHS, Constant *RHS) const { - return BinaryOperator::Create(Opc, LHS, RHS); - } - - //===--------------------------------------------------------------------===// - // Unary Operators - //===--------------------------------------------------------------------===// - - Instruction *CreateNeg(Constant *C, - bool HasNUW = false, bool HasNSW = false) const { - BinaryOperator *BO = BinaryOperator::CreateNeg(C); - if (HasNUW) BO->setHasNoUnsignedWrap(); - if (HasNSW) BO->setHasNoSignedWrap(); - return BO; - } - Instruction *CreateNSWNeg(Constant *C) const { - return BinaryOperator::CreateNSWNeg(C); - } - Instruction *CreateNUWNeg(Constant *C) const { - return BinaryOperator::CreateNUWNeg(C); - } - Instruction *CreateFNeg(Constant *C) const { - return BinaryOperator::CreateFNeg(C); - } - Instruction *CreateNot(Constant *C) const { - return BinaryOperator::CreateNot(C); - } - - //===--------------------------------------------------------------------===// - // Memory Instructions - //===--------------------------------------------------------------------===// - - Constant *CreateGetElementPtr(Constant *C, - ArrayRef IdxList) const { - return ConstantExpr::getGetElementPtr(C, IdxList); - } - Constant *CreateGetElementPtr(Constant *C, Constant *Idx) const { - // This form of the function only exists to avoid ambiguous overload - // warnings about whether to convert Idx to ArrayRef or - // ArrayRef. - return ConstantExpr::getGetElementPtr(C, Idx); - } - Instruction *CreateGetElementPtr(Constant *C, - ArrayRef IdxList) const { - return GetElementPtrInst::Create(C, IdxList); - } - - Constant *CreateInBoundsGetElementPtr(Constant *C, - ArrayRef IdxList) const { - return ConstantExpr::getInBoundsGetElementPtr(C, IdxList); - } - Constant *CreateInBoundsGetElementPtr(Constant *C, Constant *Idx) const { - // This form of the function only exists to avoid ambiguous overload - // warnings about whether to convert Idx to ArrayRef or - // ArrayRef. - return ConstantExpr::getInBoundsGetElementPtr(C, Idx); - } - Instruction *CreateInBoundsGetElementPtr(Constant *C, - ArrayRef IdxList) const { - return GetElementPtrInst::CreateInBounds(C, IdxList); - } - - //===--------------------------------------------------------------------===// - // Cast/Conversion Operators - //===--------------------------------------------------------------------===// - - Instruction *CreateCast(Instruction::CastOps Op, Constant *C, - Type *DestTy) const { - return CastInst::Create(Op, C, DestTy); - } - Instruction *CreatePointerCast(Constant *C, Type *DestTy) const { - return CastInst::CreatePointerCast(C, DestTy); - } - Instruction *CreateIntCast(Constant *C, Type *DestTy, - bool isSigned) const { - return CastInst::CreateIntegerCast(C, DestTy, isSigned); - } - Instruction *CreateFPCast(Constant *C, Type *DestTy) const { - return CastInst::CreateFPCast(C, DestTy); - } - - Instruction *CreateBitCast(Constant *C, Type *DestTy) const { - return CreateCast(Instruction::BitCast, C, DestTy); - } - Instruction *CreateIntToPtr(Constant *C, Type *DestTy) const { - return CreateCast(Instruction::IntToPtr, C, DestTy); - } - Instruction *CreatePtrToInt(Constant *C, Type *DestTy) const { - return CreateCast(Instruction::PtrToInt, C, DestTy); - } - Instruction *CreateZExtOrBitCast(Constant *C, Type *DestTy) const { - return CastInst::CreateZExtOrBitCast(C, DestTy); - } - Instruction *CreateSExtOrBitCast(Constant *C, Type *DestTy) const { - return CastInst::CreateSExtOrBitCast(C, DestTy); - } - - Instruction *CreateTruncOrBitCast(Constant *C, Type *DestTy) const { - return CastInst::CreateTruncOrBitCast(C, DestTy); - } - - //===--------------------------------------------------------------------===// - // Compare Instructions - //===--------------------------------------------------------------------===// - - Instruction *CreateICmp(CmpInst::Predicate P, - Constant *LHS, Constant *RHS) const { - return new ICmpInst(P, LHS, RHS); - } - Instruction *CreateFCmp(CmpInst::Predicate P, - Constant *LHS, Constant *RHS) const { - return new FCmpInst(P, LHS, RHS); - } - - //===--------------------------------------------------------------------===// - // Other Instructions - //===--------------------------------------------------------------------===// - - Instruction *CreateSelect(Constant *C, - Constant *True, Constant *False) const { - return SelectInst::Create(C, True, False); - } - - Instruction *CreateExtractElement(Constant *Vec, Constant *Idx) const { - return ExtractElementInst::Create(Vec, Idx); - } - - Instruction *CreateInsertElement(Constant *Vec, Constant *NewElt, - Constant *Idx) const { - return InsertElementInst::Create(Vec, NewElt, Idx); - } - - Instruction *CreateShuffleVector(Constant *V1, Constant *V2, - Constant *Mask) const { - return new ShuffleVectorInst(V1, V2, Mask); - } - - Instruction *CreateExtractValue(Constant *Agg, - ArrayRef IdxList) const { - return ExtractValueInst::Create(Agg, IdxList); - } - - Instruction *CreateInsertValue(Constant *Agg, Constant *Val, - ArrayRef IdxList) const { - return InsertValueInst::Create(Agg, Val, IdxList); - } -}; - -} - -#endif diff --git a/lib/Target/XCore/XCoreLowerThreadLocal.cpp b/lib/Target/XCore/XCoreLowerThreadLocal.cpp index da8309821c2..f9a8299fd37 100644 --- a/lib/Target/XCore/XCoreLowerThreadLocal.cpp +++ b/lib/Target/XCore/XCoreLowerThreadLocal.cpp @@ -20,10 +20,10 @@ #include "llvm/IR/IRBuilder.h" #include "llvm/IR/Intrinsics.h" #include "llvm/IR/Module.h" +#include "llvm/IR/NoFolder.h" #include "llvm/IR/ValueHandle.h" #include "llvm/Pass.h" #include "llvm/Support/CommandLine.h" -#include "llvm/Support/NoFolder.h" #include "llvm/Transforms/Utils/BasicBlockUtils.h" #define DEBUG_TYPE "xcore-lower-thread-local" diff --git a/lib/Transforms/Utils/SimplifyCFG.cpp b/lib/Transforms/Utils/SimplifyCFG.cpp index f33a1a7ec6d..9f4ce022db9 100644 --- a/lib/Transforms/Utils/SimplifyCFG.cpp +++ b/lib/Transforms/Utils/SimplifyCFG.cpp @@ -35,13 +35,13 @@ #include "llvm/IR/MDBuilder.h" #include "llvm/IR/Metadata.h" #include "llvm/IR/Module.h" +#include "llvm/IR/NoFolder.h" #include "llvm/IR/Operator.h" #include "llvm/IR/PatternMatch.h" #include "llvm/IR/Type.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/ConstantRange.h" #include "llvm/Support/Debug.h" -#include "llvm/Support/NoFolder.h" #include "llvm/Support/raw_ostream.h" #include "llvm/Transforms/Utils/BasicBlockUtils.h" #include diff --git a/unittests/IR/IRBuilderTest.cpp b/unittests/IR/IRBuilderTest.cpp index e6db8c66df0..5d67e700a9e 100644 --- a/unittests/IR/IRBuilderTest.cpp +++ b/unittests/IR/IRBuilderTest.cpp @@ -16,7 +16,7 @@ #include "llvm/IR/LLVMContext.h" #include "llvm/IR/MDBuilder.h" #include "llvm/IR/Module.h" -#include "llvm/Support/NoFolder.h" +#include "llvm/IR/NoFolder.h" #include "gtest/gtest.h" using namespace llvm; diff --git a/unittests/IR/PatternMatch.cpp b/unittests/IR/PatternMatch.cpp index 655a3d5340a..da1638163f6 100644 --- a/unittests/IR/PatternMatch.cpp +++ b/unittests/IR/PatternMatch.cpp @@ -19,10 +19,10 @@ #include "llvm/IR/LLVMContext.h" #include "llvm/IR/MDBuilder.h" #include "llvm/IR/Module.h" +#include "llvm/IR/NoFolder.h" #include "llvm/IR/Operator.h" #include "llvm/IR/PatternMatch.h" #include "llvm/IR/Type.h" -#include "llvm/Support/NoFolder.h" #include "gtest/gtest.h" using namespace llvm;