[llvm] af480e8 - Revert "[IRBuilder] Virtualize IRBuilder"
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Sun Feb 16 08:01:56 PST 2020
Author: Nikita Popov
Date: 2020-02-16T17:01:10+01:00
New Revision: af480e8c63b27ad247b8430cf124da8bcdf752f8
URL: https://github.com/llvm/llvm-project/commit/af480e8c63b27ad247b8430cf124da8bcdf752f8
DIFF: https://github.com/llvm/llvm-project/commit/af480e8c63b27ad247b8430cf124da8bcdf752f8.diff
LOG: Revert "[IRBuilder] Virtualize IRBuilder"
This reverts commit 0765d3824d069f37596bc5a890399099b776c2a0.
This reverts commit 1b04866a3db9f816a559860f941da067fe1eccf1.
Relevant looking crashes observed on:
http://lab.llvm.org:8011/builders/llvm-clang-x86_64-expensive-checks-win
Added:
Modified:
clang/lib/CodeGen/CGBuilder.h
llvm/include/llvm/Analysis/TargetFolder.h
llvm/include/llvm/IR/ConstantFolder.h
llvm/include/llvm/IR/IRBuilder.h
llvm/include/llvm/IR/NoFolder.h
llvm/lib/Analysis/ConstantFolding.cpp
llvm/lib/IR/IRBuilder.cpp
llvm/lib/Transforms/Scalar/SROA.cpp
polly/include/polly/CodeGen/IRBuilder.h
Removed:
llvm/include/llvm/IR/IRBuilderFolder.h
################################################################################
diff --git a/clang/lib/CodeGen/CGBuilder.h b/clang/lib/CodeGen/CGBuilder.h
index 38e96c0f4ee6..7687f7990d99 100644
--- a/clang/lib/CodeGen/CGBuilder.h
+++ b/clang/lib/CodeGen/CGBuilder.h
@@ -22,15 +22,16 @@ class CodeGenFunction;
/// This is an IRBuilder insertion helper that forwards to
/// CodeGenFunction::InsertHelper, which adds necessary metadata to
/// instructions.
-class CGBuilderInserter final : public llvm::IRBuilderDefaultInserter {
+class CGBuilderInserter : protected llvm::IRBuilderDefaultInserter {
public:
CGBuilderInserter() = default;
explicit CGBuilderInserter(CodeGenFunction *CGF) : CGF(CGF) {}
+protected:
/// This forwards to CodeGenFunction::InsertHelper.
void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name,
llvm::BasicBlock *BB,
- llvm::BasicBlock::iterator InsertPt) const override;
+ llvm::BasicBlock::iterator InsertPt) const;
private:
CodeGenFunction *CGF = nullptr;
};
diff --git a/llvm/include/llvm/Analysis/TargetFolder.h b/llvm/include/llvm/Analysis/TargetFolder.h
index 712c1a2e8118..7ab6562be440 100644
--- a/llvm/include/llvm/Analysis/TargetFolder.h
+++ b/llvm/include/llvm/Analysis/TargetFolder.h
@@ -22,14 +22,13 @@
#include "llvm/Analysis/ConstantFolding.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/InstrTypes.h"
-#include "llvm/IR/IRBuilderFolder.h"
namespace llvm {
class DataLayout;
/// TargetFolder - Create constants with target dependent folding.
-class TargetFolder final : public IRBuilderFolder {
+class TargetFolder {
const DataLayout &DL;
/// Fold - Fold the constant using target specific information.
@@ -39,8 +38,6 @@ class TargetFolder final : public IRBuilderFolder {
return C;
}
- virtual void anchor();
-
public:
explicit TargetFolder(const DataLayout &DL) : DL(DL) {}
@@ -49,70 +46,66 @@ class TargetFolder final : public IRBuilderFolder {
//===--------------------------------------------------------------------===//
Constant *CreateAdd(Constant *LHS, Constant *RHS,
- bool HasNUW = false, bool HasNSW = false) const override {
+ bool HasNUW = false, bool HasNSW = false) const {
return Fold(ConstantExpr::getAdd(LHS, RHS, HasNUW, HasNSW));
}
- Constant *CreateFAdd(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateFAdd(Constant *LHS, Constant *RHS) const {
return Fold(ConstantExpr::getFAdd(LHS, RHS));
}
Constant *CreateSub(Constant *LHS, Constant *RHS,
- bool HasNUW = false, bool HasNSW = false) const override {
+ bool HasNUW = false, bool HasNSW = false) const {
return Fold(ConstantExpr::getSub(LHS, RHS, HasNUW, HasNSW));
}
- Constant *CreateFSub(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateFSub(Constant *LHS, Constant *RHS) const {
return Fold(ConstantExpr::getFSub(LHS, RHS));
}
Constant *CreateMul(Constant *LHS, Constant *RHS,
- bool HasNUW = false, bool HasNSW = false) const override {
+ bool HasNUW = false, bool HasNSW = false) const {
return Fold(ConstantExpr::getMul(LHS, RHS, HasNUW, HasNSW));
}
- Constant *CreateFMul(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateFMul(Constant *LHS, Constant *RHS) const {
return Fold(ConstantExpr::getFMul(LHS, RHS));
}
- Constant *CreateUDiv(Constant *LHS, Constant *RHS,
- bool isExact = false) const override {
+ Constant *CreateUDiv(Constant *LHS, Constant *RHS, bool isExact = false)const{
return Fold(ConstantExpr::getUDiv(LHS, RHS, isExact));
}
- Constant *CreateSDiv(Constant *LHS, Constant *RHS,
- bool isExact = false) const override {
+ Constant *CreateSDiv(Constant *LHS, Constant *RHS, bool isExact = false)const{
return Fold(ConstantExpr::getSDiv(LHS, RHS, isExact));
}
- Constant *CreateFDiv(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateFDiv(Constant *LHS, Constant *RHS) const {
return Fold(ConstantExpr::getFDiv(LHS, RHS));
}
- Constant *CreateURem(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateURem(Constant *LHS, Constant *RHS) const {
return Fold(ConstantExpr::getURem(LHS, RHS));
}
- Constant *CreateSRem(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateSRem(Constant *LHS, Constant *RHS) const {
return Fold(ConstantExpr::getSRem(LHS, RHS));
}
- Constant *CreateFRem(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateFRem(Constant *LHS, Constant *RHS) const {
return Fold(ConstantExpr::getFRem(LHS, RHS));
}
Constant *CreateShl(Constant *LHS, Constant *RHS,
- bool HasNUW = false, bool HasNSW = false) const override {
+ bool HasNUW = false, bool HasNSW = false) const {
return Fold(ConstantExpr::getShl(LHS, RHS, HasNUW, HasNSW));
}
- Constant *CreateLShr(Constant *LHS, Constant *RHS,
- bool isExact = false) const override {
+ Constant *CreateLShr(Constant *LHS, Constant *RHS, bool isExact = false)const{
return Fold(ConstantExpr::getLShr(LHS, RHS, isExact));
}
- Constant *CreateAShr(Constant *LHS, Constant *RHS,
- bool isExact = false) const override {
+ Constant *CreateAShr(Constant *LHS, Constant *RHS, bool isExact = false)const{
return Fold(ConstantExpr::getAShr(LHS, RHS, isExact));
}
- Constant *CreateAnd(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateAnd(Constant *LHS, Constant *RHS) const {
return Fold(ConstantExpr::getAnd(LHS, RHS));
}
- Constant *CreateOr(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateOr(Constant *LHS, Constant *RHS) const {
return Fold(ConstantExpr::getOr(LHS, RHS));
}
- Constant *CreateXor(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateXor(Constant *LHS, Constant *RHS) const {
return Fold(ConstantExpr::getXor(LHS, RHS));
}
Constant *CreateBinOp(Instruction::BinaryOps Opc,
- Constant *LHS, Constant *RHS) const override {
+ Constant *LHS, Constant *RHS) const {
return Fold(ConstantExpr::get(Opc, LHS, RHS));
}
@@ -121,17 +114,17 @@ class TargetFolder final : public IRBuilderFolder {
//===--------------------------------------------------------------------===//
Constant *CreateNeg(Constant *C,
- bool HasNUW = false, bool HasNSW = false) const override {
+ bool HasNUW = false, bool HasNSW = false) const {
return Fold(ConstantExpr::getNeg(C, HasNUW, HasNSW));
}
- Constant *CreateFNeg(Constant *C) const override {
+ Constant *CreateFNeg(Constant *C) const {
return Fold(ConstantExpr::getFNeg(C));
}
- Constant *CreateNot(Constant *C) const override {
+ Constant *CreateNot(Constant *C) const {
return Fold(ConstantExpr::getNot(C));
}
- Constant *CreateUnOp(Instruction::UnaryOps Opc, Constant *C) const override {
+ Constant *CreateUnOp(Instruction::UnaryOps Opc, Constant *C) const {
return Fold(ConstantExpr::get(Opc, C));
}
@@ -140,34 +133,33 @@ class TargetFolder final : public IRBuilderFolder {
//===--------------------------------------------------------------------===//
Constant *CreateGetElementPtr(Type *Ty, Constant *C,
- ArrayRef<Constant *> IdxList) const override {
+ ArrayRef<Constant *> IdxList) const {
return Fold(ConstantExpr::getGetElementPtr(Ty, C, IdxList));
}
- Constant *CreateGetElementPtr(Type *Ty, Constant *C,
- Constant *Idx) const override {
+ Constant *CreateGetElementPtr(Type *Ty, Constant *C, Constant *Idx) const {
// This form of the function only exists to avoid ambiguous overload
// warnings about whether to convert Idx to ArrayRef<Constant *> or
// ArrayRef<Value *>.
return Fold(ConstantExpr::getGetElementPtr(Ty, C, Idx));
}
Constant *CreateGetElementPtr(Type *Ty, Constant *C,
- ArrayRef<Value *> IdxList) const override {
+ ArrayRef<Value *> IdxList) const {
return Fold(ConstantExpr::getGetElementPtr(Ty, C, IdxList));
}
- Constant *CreateInBoundsGetElementPtr(
- Type *Ty, Constant *C, ArrayRef<Constant *> IdxList) const override {
+ Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
+ ArrayRef<Constant *> IdxList) const {
return Fold(ConstantExpr::getInBoundsGetElementPtr(Ty, C, IdxList));
}
Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
- Constant *Idx) const override {
+ Constant *Idx) const {
// This form of the function only exists to avoid ambiguous overload
// warnings about whether to convert Idx to ArrayRef<Constant *> or
// ArrayRef<Value *>.
return Fold(ConstantExpr::getInBoundsGetElementPtr(Ty, C, Idx));
}
- Constant *CreateInBoundsGetElementPtr(
- Type *Ty, Constant *C, ArrayRef<Value *> IdxList) const override {
+ Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
+ ArrayRef<Value *> IdxList) const {
return Fold(ConstantExpr::getInBoundsGetElementPtr(Ty, C, IdxList));
}
@@ -176,54 +168,54 @@ class TargetFolder final : public IRBuilderFolder {
//===--------------------------------------------------------------------===//
Constant *CreateCast(Instruction::CastOps Op, Constant *C,
- Type *DestTy) const override {
+ Type *DestTy) const {
if (C->getType() == DestTy)
return C; // avoid calling Fold
return Fold(ConstantExpr::getCast(Op, C, DestTy));
}
Constant *CreateIntCast(Constant *C, Type *DestTy,
- bool isSigned) const override {
+ bool isSigned) const {
if (C->getType() == DestTy)
return C; // avoid calling Fold
return Fold(ConstantExpr::getIntegerCast(C, DestTy, isSigned));
}
- Constant *CreatePointerCast(Constant *C, Type *DestTy) const override {
+ Constant *CreatePointerCast(Constant *C, Type *DestTy) const {
if (C->getType() == DestTy)
return C; // avoid calling Fold
return Fold(ConstantExpr::getPointerCast(C, DestTy));
}
- Constant *CreateFPCast(Constant *C, Type *DestTy) const override {
+ Constant *CreateFPCast(Constant *C, Type *DestTy) const {
if (C->getType() == DestTy)
return C; // avoid calling Fold
return Fold(ConstantExpr::getFPCast(C, DestTy));
}
- Constant *CreateBitCast(Constant *C, Type *DestTy) const override {
+ Constant *CreateBitCast(Constant *C, Type *DestTy) const {
return CreateCast(Instruction::BitCast, C, DestTy);
}
- Constant *CreateIntToPtr(Constant *C, Type *DestTy) const override {
+ Constant *CreateIntToPtr(Constant *C, Type *DestTy) const {
return CreateCast(Instruction::IntToPtr, C, DestTy);
}
- Constant *CreatePtrToInt(Constant *C, Type *DestTy) const override {
+ Constant *CreatePtrToInt(Constant *C, Type *DestTy) const {
return CreateCast(Instruction::PtrToInt, C, DestTy);
}
- Constant *CreateZExtOrBitCast(Constant *C, Type *DestTy) const override {
+ Constant *CreateZExtOrBitCast(Constant *C, Type *DestTy) const {
if (C->getType() == DestTy)
return C; // avoid calling Fold
return Fold(ConstantExpr::getZExtOrBitCast(C, DestTy));
}
- Constant *CreateSExtOrBitCast(Constant *C, Type *DestTy) const override {
+ Constant *CreateSExtOrBitCast(Constant *C, Type *DestTy) const {
if (C->getType() == DestTy)
return C; // avoid calling Fold
return Fold(ConstantExpr::getSExtOrBitCast(C, DestTy));
}
- Constant *CreateTruncOrBitCast(Constant *C, Type *DestTy) const override {
+ Constant *CreateTruncOrBitCast(Constant *C, Type *DestTy) const {
if (C->getType() == DestTy)
return C; // avoid calling Fold
return Fold(ConstantExpr::getTruncOrBitCast(C, DestTy));
}
Constant *CreatePointerBitCastOrAddrSpaceCast(Constant *C,
- Type *DestTy) const override {
+ Type *DestTy) const {
if (C->getType() == DestTy)
return C; // avoid calling Fold
return Fold(ConstantExpr::getPointerBitCastOrAddrSpaceCast(C, DestTy));
@@ -234,11 +226,11 @@ class TargetFolder final : public IRBuilderFolder {
//===--------------------------------------------------------------------===//
Constant *CreateICmp(CmpInst::Predicate P, Constant *LHS,
- Constant *RHS) const override {
+ Constant *RHS) const {
return Fold(ConstantExpr::getCompare(P, LHS, RHS));
}
Constant *CreateFCmp(CmpInst::Predicate P, Constant *LHS,
- Constant *RHS) const override {
+ Constant *RHS) const {
return Fold(ConstantExpr::getCompare(P, LHS, RHS));
}
@@ -246,32 +238,31 @@ class TargetFolder final : public IRBuilderFolder {
// Other Instructions
//===--------------------------------------------------------------------===//
- Constant *CreateSelect(Constant *C, Constant *True,
- Constant *False) const override {
+ Constant *CreateSelect(Constant *C, Constant *True, Constant *False) const {
return Fold(ConstantExpr::getSelect(C, True, False));
}
- Constant *CreateExtractElement(Constant *Vec, Constant *Idx) const override {
+ Constant *CreateExtractElement(Constant *Vec, Constant *Idx) const {
return Fold(ConstantExpr::getExtractElement(Vec, Idx));
}
Constant *CreateInsertElement(Constant *Vec, Constant *NewElt,
- Constant *Idx) const override {
+ Constant *Idx) const {
return Fold(ConstantExpr::getInsertElement(Vec, NewElt, Idx));
}
Constant *CreateShuffleVector(Constant *V1, Constant *V2,
- Constant *Mask) const override {
+ Constant *Mask) const {
return Fold(ConstantExpr::getShuffleVector(V1, V2, Mask));
}
Constant *CreateExtractValue(Constant *Agg,
- ArrayRef<unsigned> IdxList) const override {
+ ArrayRef<unsigned> IdxList) const {
return Fold(ConstantExpr::getExtractValue(Agg, IdxList));
}
Constant *CreateInsertValue(Constant *Agg, Constant *Val,
- ArrayRef<unsigned> IdxList) const override {
+ ArrayRef<unsigned> IdxList) const {
return Fold(ConstantExpr::getInsertValue(Agg, Val, IdxList));
}
};
diff --git a/llvm/include/llvm/IR/ConstantFolder.h b/llvm/include/llvm/IR/ConstantFolder.h
index 32939e79cd1d..5a5cabfd0206 100644
--- a/llvm/include/llvm/IR/ConstantFolder.h
+++ b/llvm/include/llvm/IR/ConstantFolder.h
@@ -20,14 +20,11 @@
#include "llvm/IR/Constants.h"
#include "llvm/IR/InstrTypes.h"
#include "llvm/IR/Instruction.h"
-#include "llvm/IR/IRBuilderFolder.h"
namespace llvm {
/// ConstantFolder - Create constants with minimum, target independent, folding.
-class ConstantFolder final : public IRBuilderFolder {
- virtual void anchor();
-
+class ConstantFolder {
public:
explicit ConstantFolder() = default;
@@ -36,87 +33,87 @@ class ConstantFolder final : public IRBuilderFolder {
//===--------------------------------------------------------------------===//
Constant *CreateAdd(Constant *LHS, Constant *RHS,
- bool HasNUW = false, bool HasNSW = false) const override {
+ bool HasNUW = false, bool HasNSW = false) const {
return ConstantExpr::getAdd(LHS, RHS, HasNUW, HasNSW);
}
- Constant *CreateFAdd(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateFAdd(Constant *LHS, Constant *RHS) const {
return ConstantExpr::getFAdd(LHS, RHS);
}
Constant *CreateSub(Constant *LHS, Constant *RHS,
- bool HasNUW = false, bool HasNSW = false) const override {
+ bool HasNUW = false, bool HasNSW = false) const {
return ConstantExpr::getSub(LHS, RHS, HasNUW, HasNSW);
}
- Constant *CreateFSub(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateFSub(Constant *LHS, Constant *RHS) const {
return ConstantExpr::getFSub(LHS, RHS);
}
Constant *CreateMul(Constant *LHS, Constant *RHS,
- bool HasNUW = false, bool HasNSW = false) const override {
+ bool HasNUW = false, bool HasNSW = false) const {
return ConstantExpr::getMul(LHS, RHS, HasNUW, HasNSW);
}
- Constant *CreateFMul(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateFMul(Constant *LHS, Constant *RHS) const {
return ConstantExpr::getFMul(LHS, RHS);
}
Constant *CreateUDiv(Constant *LHS, Constant *RHS,
- bool isExact = false) const override {
+ bool isExact = false) const {
return ConstantExpr::getUDiv(LHS, RHS, isExact);
}
Constant *CreateSDiv(Constant *LHS, Constant *RHS,
- bool isExact = false) const override {
+ bool isExact = false) const {
return ConstantExpr::getSDiv(LHS, RHS, isExact);
}
- Constant *CreateFDiv(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateFDiv(Constant *LHS, Constant *RHS) const {
return ConstantExpr::getFDiv(LHS, RHS);
}
- Constant *CreateURem(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateURem(Constant *LHS, Constant *RHS) const {
return ConstantExpr::getURem(LHS, RHS);
}
- Constant *CreateSRem(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateSRem(Constant *LHS, Constant *RHS) const {
return ConstantExpr::getSRem(LHS, RHS);
}
- Constant *CreateFRem(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateFRem(Constant *LHS, Constant *RHS) const {
return ConstantExpr::getFRem(LHS, RHS);
}
Constant *CreateShl(Constant *LHS, Constant *RHS,
- bool HasNUW = false, bool HasNSW = false) const override {
+ bool HasNUW = false, bool HasNSW = false) const {
return ConstantExpr::getShl(LHS, RHS, HasNUW, HasNSW);
}
Constant *CreateLShr(Constant *LHS, Constant *RHS,
- bool isExact = false) const override {
+ bool isExact = false) const {
return ConstantExpr::getLShr(LHS, RHS, isExact);
}
Constant *CreateAShr(Constant *LHS, Constant *RHS,
- bool isExact = false) const override {
+ bool isExact = false) const {
return ConstantExpr::getAShr(LHS, RHS, isExact);
}
- Constant *CreateAnd(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateAnd(Constant *LHS, Constant *RHS) const {
return ConstantExpr::getAnd(LHS, RHS);
}
- Constant *CreateOr(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateOr(Constant *LHS, Constant *RHS) const {
return ConstantExpr::getOr(LHS, RHS);
}
- Constant *CreateXor(Constant *LHS, Constant *RHS) const override {
+ Constant *CreateXor(Constant *LHS, Constant *RHS) const {
return ConstantExpr::getXor(LHS, RHS);
}
Constant *CreateBinOp(Instruction::BinaryOps Opc,
- Constant *LHS, Constant *RHS) const override {
+ Constant *LHS, Constant *RHS) const {
return ConstantExpr::get(Opc, LHS, RHS);
}
@@ -125,19 +122,19 @@ class ConstantFolder final : public IRBuilderFolder {
//===--------------------------------------------------------------------===//
Constant *CreateNeg(Constant *C,
- bool HasNUW = false, bool HasNSW = false) const override {
+ bool HasNUW = false, bool HasNSW = false) const {
return ConstantExpr::getNeg(C, HasNUW, HasNSW);
}
- Constant *CreateFNeg(Constant *C) const override {
+ Constant *CreateFNeg(Constant *C) const {
return ConstantExpr::getFNeg(C);
}
- Constant *CreateNot(Constant *C) const override {
+ Constant *CreateNot(Constant *C) const {
return ConstantExpr::getNot(C);
}
- Constant *CreateUnOp(Instruction::UnaryOps Opc, Constant *C) const override {
+ Constant *CreateUnOp(Instruction::UnaryOps Opc, Constant *C) const {
return ConstantExpr::get(Opc, C);
}
@@ -146,12 +143,11 @@ class ConstantFolder final : public IRBuilderFolder {
//===--------------------------------------------------------------------===//
Constant *CreateGetElementPtr(Type *Ty, Constant *C,
- ArrayRef<Constant *> IdxList) const override {
+ ArrayRef<Constant *> IdxList) const {
return ConstantExpr::getGetElementPtr(Ty, C, IdxList);
}
- Constant *CreateGetElementPtr(Type *Ty, Constant *C,
- Constant *Idx) const override {
+ Constant *CreateGetElementPtr(Type *Ty, Constant *C, Constant *Idx) const {
// This form of the function only exists to avoid ambiguous overload
// warnings about whether to convert Idx to ArrayRef<Constant *> or
// ArrayRef<Value *>.
@@ -159,25 +155,25 @@ class ConstantFolder final : public IRBuilderFolder {
}
Constant *CreateGetElementPtr(Type *Ty, Constant *C,
- ArrayRef<Value *> IdxList) const override {
+ ArrayRef<Value *> IdxList) const {
return ConstantExpr::getGetElementPtr(Ty, C, IdxList);
}
- Constant *CreateInBoundsGetElementPtr(
- Type *Ty, Constant *C, ArrayRef<Constant *> IdxList) const override {
+ Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
+ ArrayRef<Constant *> IdxList) const {
return ConstantExpr::getInBoundsGetElementPtr(Ty, C, IdxList);
}
Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
- Constant *Idx) const override {
+ Constant *Idx) const {
// This form of the function only exists to avoid ambiguous overload
// warnings about whether to convert Idx to ArrayRef<Constant *> or
// ArrayRef<Value *>.
return ConstantExpr::getInBoundsGetElementPtr(Ty, C, Idx);
}
- Constant *CreateInBoundsGetElementPtr(
- Type *Ty, Constant *C, ArrayRef<Value *> IdxList) const override {
+ Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
+ ArrayRef<Value *> IdxList) const {
return ConstantExpr::getInBoundsGetElementPtr(Ty, C, IdxList);
}
@@ -186,49 +182,49 @@ class ConstantFolder final : public IRBuilderFolder {
//===--------------------------------------------------------------------===//
Constant *CreateCast(Instruction::CastOps Op, Constant *C,
- Type *DestTy) const override {
+ Type *DestTy) const {
return ConstantExpr::getCast(Op, C, DestTy);
}
- Constant *CreatePointerCast(Constant *C, Type *DestTy) const override {
+ Constant *CreatePointerCast(Constant *C, Type *DestTy) const {
return ConstantExpr::getPointerCast(C, DestTy);
}
Constant *CreatePointerBitCastOrAddrSpaceCast(Constant *C,
- Type *DestTy) const override {
+ Type *DestTy) const {
return ConstantExpr::getPointerBitCastOrAddrSpaceCast(C, DestTy);
}
Constant *CreateIntCast(Constant *C, Type *DestTy,
- bool isSigned) const override {
+ bool isSigned) const {
return ConstantExpr::getIntegerCast(C, DestTy, isSigned);
}
- Constant *CreateFPCast(Constant *C, Type *DestTy) const override {
+ Constant *CreateFPCast(Constant *C, Type *DestTy) const {
return ConstantExpr::getFPCast(C, DestTy);
}
- Constant *CreateBitCast(Constant *C, Type *DestTy) const override {
+ Constant *CreateBitCast(Constant *C, Type *DestTy) const {
return CreateCast(Instruction::BitCast, C, DestTy);
}
- Constant *CreateIntToPtr(Constant *C, Type *DestTy) const override {
+ Constant *CreateIntToPtr(Constant *C, Type *DestTy) const {
return CreateCast(Instruction::IntToPtr, C, DestTy);
}
- Constant *CreatePtrToInt(Constant *C, Type *DestTy) const override {
+ Constant *CreatePtrToInt(Constant *C, Type *DestTy) const {
return CreateCast(Instruction::PtrToInt, C, DestTy);
}
- Constant *CreateZExtOrBitCast(Constant *C, Type *DestTy) const override {
+ Constant *CreateZExtOrBitCast(Constant *C, Type *DestTy) const {
return ConstantExpr::getZExtOrBitCast(C, DestTy);
}
- Constant *CreateSExtOrBitCast(Constant *C, Type *DestTy) const override {
+ Constant *CreateSExtOrBitCast(Constant *C, Type *DestTy) const {
return ConstantExpr::getSExtOrBitCast(C, DestTy);
}
- Constant *CreateTruncOrBitCast(Constant *C, Type *DestTy) const override {
+ Constant *CreateTruncOrBitCast(Constant *C, Type *DestTy) const {
return ConstantExpr::getTruncOrBitCast(C, DestTy);
}
@@ -237,12 +233,12 @@ class ConstantFolder final : public IRBuilderFolder {
//===--------------------------------------------------------------------===//
Constant *CreateICmp(CmpInst::Predicate P, Constant *LHS,
- Constant *RHS) const override {
+ Constant *RHS) const {
return ConstantExpr::getCompare(P, LHS, RHS);
}
Constant *CreateFCmp(CmpInst::Predicate P, Constant *LHS,
- Constant *RHS) const override {
+ Constant *RHS) const {
return ConstantExpr::getCompare(P, LHS, RHS);
}
@@ -250,32 +246,31 @@ class ConstantFolder final : public IRBuilderFolder {
// Other Instructions
//===--------------------------------------------------------------------===//
- Constant *CreateSelect(Constant *C, Constant *True,
- Constant *False) const override {
+ Constant *CreateSelect(Constant *C, Constant *True, Constant *False) const {
return ConstantExpr::getSelect(C, True, False);
}
- Constant *CreateExtractElement(Constant *Vec, Constant *Idx) const override {
+ Constant *CreateExtractElement(Constant *Vec, Constant *Idx) const {
return ConstantExpr::getExtractElement(Vec, Idx);
}
Constant *CreateInsertElement(Constant *Vec, Constant *NewElt,
- Constant *Idx) const override {
+ Constant *Idx) const {
return ConstantExpr::getInsertElement(Vec, NewElt, Idx);
}
Constant *CreateShuffleVector(Constant *V1, Constant *V2,
- Constant *Mask) const override {
+ Constant *Mask) const {
return ConstantExpr::getShuffleVector(V1, V2, Mask);
}
Constant *CreateExtractValue(Constant *Agg,
- ArrayRef<unsigned> IdxList) const override {
+ ArrayRef<unsigned> IdxList) const {
return ConstantExpr::getExtractValue(Agg, IdxList);
}
Constant *CreateInsertValue(Constant *Agg, Constant *Val,
- ArrayRef<unsigned> IdxList) const override {
+ ArrayRef<unsigned> IdxList) const {
return ConstantExpr::getInsertValue(Agg, Val, IdxList);
}
};
diff --git a/llvm/include/llvm/IR/IRBuilder.h b/llvm/include/llvm/IR/IRBuilder.h
index bca153b68ae9..82cd0738ac28 100644
--- a/llvm/include/llvm/IR/IRBuilder.h
+++ b/llvm/include/llvm/IR/IRBuilder.h
@@ -59,12 +59,9 @@ class Use;
///
/// By default, this inserts the instruction at the insertion point.
class IRBuilderDefaultInserter {
-public:
- virtual ~IRBuilderDefaultInserter();
-
- virtual void InsertHelper(Instruction *I, const Twine &Name,
- BasicBlock *BB,
- BasicBlock::iterator InsertPt) const {
+protected:
+ void InsertHelper(Instruction *I, const Twine &Name,
+ BasicBlock *BB, BasicBlock::iterator InsertPt) const {
if (BB) BB->getInstList().insert(InsertPt, I);
I->setName(Name);
}
@@ -72,18 +69,16 @@ class IRBuilderDefaultInserter {
/// Provides an 'InsertHelper' that calls a user-provided callback after
/// performing the default insertion.
-class IRBuilderCallbackInserter : public IRBuilderDefaultInserter {
+class IRBuilderCallbackInserter : IRBuilderDefaultInserter {
std::function<void(Instruction *)> Callback;
public:
- virtual ~IRBuilderCallbackInserter();
-
IRBuilderCallbackInserter(std::function<void(Instruction *)> Callback)
: Callback(std::move(Callback)) {}
+protected:
void InsertHelper(Instruction *I, const Twine &Name,
- BasicBlock *BB,
- BasicBlock::iterator InsertPt) const override {
+ BasicBlock *BB, BasicBlock::iterator InsertPt) const {
IRBuilderDefaultInserter::InsertHelper(I, Name, BB, InsertPt);
Callback(I);
}
@@ -97,8 +92,6 @@ class IRBuilderBase {
BasicBlock *BB;
BasicBlock::iterator InsertPt;
LLVMContext &Context;
- const IRBuilderFolder &Folder;
- const IRBuilderDefaultInserter &Inserter;
MDNode *DefaultFPMathTag;
FastMathFlags FMF;
@@ -110,37 +103,15 @@ class IRBuilderBase {
ArrayRef<OperandBundleDef> DefaultOperandBundles;
public:
- IRBuilderBase(LLVMContext &context, const IRBuilderFolder &Folder,
- const IRBuilderDefaultInserter &Inserter,
- MDNode *FPMathTag, ArrayRef<OperandBundleDef> OpBundles)
- : Context(context), Folder(Folder), Inserter(Inserter),
- DefaultFPMathTag(FPMathTag), IsFPConstrained(false),
+ IRBuilderBase(LLVMContext &context, MDNode *FPMathTag = nullptr,
+ ArrayRef<OperandBundleDef> OpBundles = None)
+ : Context(context), DefaultFPMathTag(FPMathTag), IsFPConstrained(false),
DefaultConstrainedExcept(fp::ebStrict),
DefaultConstrainedRounding(fp::rmDynamic),
DefaultOperandBundles(OpBundles) {
ClearInsertionPoint();
}
- /// Insert and return the specified instruction.
- template<typename InstTy>
- InstTy *Insert(InstTy *I, const Twine &Name = "") const {
- Inserter.InsertHelper(I, Name, BB, InsertPt);
- SetInstDebugLocation(I);
- return I;
- }
-
- /// No-op overload to handle constants.
- Constant *Insert(Constant *C, const Twine& = "") const {
- return C;
- }
-
- Value *Insert(Value *V, const Twine& = "") const {
- if (Instruction *I = dyn_cast<Instruction>(V))
- return Insert(I);
- assert(isa<Constant>(V));
- return V;
- }
-
//===--------------------------------------------------------------------===//
// Builder configuration methods
//===--------------------------------------------------------------------===//
@@ -949,7 +920,85 @@ class IRBuilderBase {
const Twine &Name = "");
Value *getCastedInt8PtrValue(Value *Ptr);
+};
+/// This provides a uniform API for creating instructions and inserting
+/// them into a basic block: either at the end of a BasicBlock, or at a specific
+/// iterator location in a block.
+///
+/// Note that the builder does not expose the full generality of LLVM
+/// instructions. For access to extra instruction properties, use the mutators
+/// (e.g. setVolatile) on the instructions after they have been
+/// created. Convenience state exists to specify fast-math flags and fp-math
+/// tags.
+///
+/// The first template argument specifies a class to use for creating constants.
+/// This defaults to creating minimally folded constants. The second template
+/// argument allows clients to specify custom insertion hooks that are called on
+/// every newly created insertion.
+template <typename T = ConstantFolder,
+ typename Inserter = IRBuilderDefaultInserter>
+class IRBuilder : public IRBuilderBase, public Inserter {
+ T Folder;
+
+public:
+ IRBuilder(LLVMContext &C, const T &F, Inserter I = Inserter(),
+ MDNode *FPMathTag = nullptr,
+ ArrayRef<OperandBundleDef> OpBundles = None)
+ : IRBuilderBase(C, FPMathTag, OpBundles), Inserter(std::move(I)),
+ Folder(F) {}
+
+ explicit IRBuilder(LLVMContext &C, MDNode *FPMathTag = nullptr,
+ ArrayRef<OperandBundleDef> OpBundles = None)
+ : IRBuilderBase(C, FPMathTag, OpBundles) {}
+
+ explicit IRBuilder(BasicBlock *TheBB, const T &F, MDNode *FPMathTag = nullptr,
+ ArrayRef<OperandBundleDef> OpBundles = None)
+ : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles), Folder(F) {
+ SetInsertPoint(TheBB);
+ }
+
+ explicit IRBuilder(BasicBlock *TheBB, MDNode *FPMathTag = nullptr,
+ ArrayRef<OperandBundleDef> OpBundles = None)
+ : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles) {
+ SetInsertPoint(TheBB);
+ }
+
+ explicit IRBuilder(Instruction *IP, MDNode *FPMathTag = nullptr,
+ ArrayRef<OperandBundleDef> OpBundles = None)
+ : IRBuilderBase(IP->getContext(), FPMathTag, OpBundles) {
+ SetInsertPoint(IP);
+ }
+
+ IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, const T &F,
+ MDNode *FPMathTag = nullptr,
+ ArrayRef<OperandBundleDef> OpBundles = None)
+ : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles), Folder(F) {
+ SetInsertPoint(TheBB, IP);
+ }
+
+ IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP,
+ MDNode *FPMathTag = nullptr,
+ ArrayRef<OperandBundleDef> OpBundles = None)
+ : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles) {
+ SetInsertPoint(TheBB, IP);
+ }
+
+ /// Get the constant folder being used.
+ const T &getFolder() { return Folder; }
+
+ /// Insert and return the specified instruction.
+ template<typename InstTy>
+ InstTy *Insert(InstTy *I, const Twine &Name = "") const {
+ this->InsertHelper(I, Name, BB, InsertPt);
+ this->SetInstDebugLocation(I);
+ return I;
+ }
+
+ /// No-op overload to handle constants.
+ Constant *Insert(Constant *C, const Twine& = "") const {
+ return C;
+ }
//===--------------------------------------------------------------------===//
// Instruction creation methods: Terminators
@@ -2927,79 +2976,6 @@ class IRBuilderBase {
}
};
-/// This provides a uniform API for creating instructions and inserting
-/// them into a basic block: either at the end of a BasicBlock, or at a specific
-/// iterator location in a block.
-///
-/// Note that the builder does not expose the full generality of LLVM
-/// instructions. For access to extra instruction properties, use the mutators
-/// (e.g. setVolatile) on the instructions after they have been
-/// created. Convenience state exists to specify fast-math flags and fp-math
-/// tags.
-///
-/// The first template argument specifies a class to use for creating constants.
-/// This defaults to creating minimally folded constants. The second template
-/// argument allows clients to specify custom insertion hooks that are called on
-/// every newly created insertion.
-template <typename FolderTy = ConstantFolder,
- typename InserterTy = IRBuilderDefaultInserter>
-class IRBuilder : public IRBuilderBase {
-private:
- FolderTy Folder;
- InserterTy Inserter;
-
-public:
- IRBuilder(LLVMContext &C, FolderTy Folder, InserterTy Inserter = InserterTy(),
- MDNode *FPMathTag = nullptr,
- ArrayRef<OperandBundleDef> OpBundles = None)
- : IRBuilderBase(C, this->Folder, this->Inserter, FPMathTag, OpBundles),
- Folder(Folder), Inserter(Inserter) {}
-
- explicit IRBuilder(LLVMContext &C, MDNode *FPMathTag = nullptr,
- ArrayRef<OperandBundleDef> OpBundles = None)
- : IRBuilderBase(C, this->Folder, this->Inserter, FPMathTag, OpBundles) {}
-
- explicit IRBuilder(BasicBlock *TheBB, FolderTy Folder,
- MDNode *FPMathTag = nullptr,
- ArrayRef<OperandBundleDef> OpBundles = None)
- : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
- FPMathTag, OpBundles), Folder(Folder) {
- SetInsertPoint(TheBB);
- }
-
- explicit IRBuilder(BasicBlock *TheBB, MDNode *FPMathTag = nullptr,
- ArrayRef<OperandBundleDef> OpBundles = None)
- : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
- FPMathTag, OpBundles) {
- SetInsertPoint(TheBB);
- }
-
- explicit IRBuilder(Instruction *IP, MDNode *FPMathTag = nullptr,
- ArrayRef<OperandBundleDef> OpBundles = None)
- : IRBuilderBase(IP->getContext(), this->Folder, this->Inserter,
- FPMathTag, OpBundles) {
- SetInsertPoint(IP);
- }
-
- IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, FolderTy Folder,
- MDNode *FPMathTag = nullptr,
- ArrayRef<OperandBundleDef> OpBundles = None)
- : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
- FPMathTag, OpBundles), Folder(Folder) {
- SetInsertPoint(TheBB, IP);
- }
-
- IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP,
- MDNode *FPMathTag = nullptr,
- ArrayRef<OperandBundleDef> OpBundles = None)
- : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
- FPMathTag, OpBundles) {
- SetInsertPoint(TheBB, IP);
- }
-
- InserterTy &getInserter() { return Inserter; }
-};
-
// Create wrappers for C Binding types (see CBindingWrapping.h).
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef)
diff --git a/llvm/include/llvm/IR/IRBuilderFolder.h b/llvm/include/llvm/IR/IRBuilderFolder.h
deleted file mode 100644
index a77a5213dcea..000000000000
--- a/llvm/include/llvm/IR/IRBuilderFolder.h
+++ /dev/null
@@ -1,141 +0,0 @@
-//===- IRBuilderFolder.h - Const folder interface for IRBuilder -*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines for constant folding interface used by IRBuilder.
-// It is implemented by ConstantFolder (default), TargetFolder and NoFoler.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_IR_IRBUILDERFOLDER_H
-#define LLVM_IR_IRBUILDERFOLDER_H
-
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/IR/InstrTypes.h"
-#include "llvm/IR/Instruction.h"
-
-namespace llvm {
-
-/// IRBuilderFolder - Interface for constant folding in IRBuilder.
-class IRBuilderFolder {
-public:
- virtual ~IRBuilderFolder();
-
- //===--------------------------------------------------------------------===//
- // Binary Operators
- //===--------------------------------------------------------------------===//
-
- virtual Value *CreateAdd(Constant *LHS, Constant *RHS,
- bool HasNUW = false, bool HasNSW = false) const = 0;
- virtual Value *CreateFAdd(Constant *LHS, Constant *RHS) const = 0;
- virtual Value *CreateSub(Constant *LHS, Constant *RHS,
- bool HasNUW = false, bool HasNSW = false) const = 0;
- virtual Value *CreateFSub(Constant *LHS, Constant *RHS) const = 0;
- virtual Value *CreateMul(Constant *LHS, Constant *RHS,
- bool HasNUW = false, bool HasNSW = false) const = 0;
- virtual Value *CreateFMul(Constant *LHS, Constant *RHS) const = 0;
- virtual Value *CreateUDiv(Constant *LHS, Constant *RHS,
- bool isExact = false) const = 0;
- virtual Value *CreateSDiv(Constant *LHS, Constant *RHS,
- bool isExact = false) const = 0;
- virtual Value *CreateFDiv(Constant *LHS, Constant *RHS) const = 0;
- virtual Value *CreateURem(Constant *LHS, Constant *RHS) const = 0;
- virtual Value *CreateSRem(Constant *LHS, Constant *RHS) const = 0;
- virtual Value *CreateFRem(Constant *LHS, Constant *RHS) const = 0;
- virtual Value *CreateShl(Constant *LHS, Constant *RHS,
- bool HasNUW = false, bool HasNSW = false) const = 0;
- virtual Value *CreateLShr(Constant *LHS, Constant *RHS,
- bool isExact = false) const = 0;
- virtual Value *CreateAShr(Constant *LHS, Constant *RHS,
- bool isExact = false) const = 0;
- virtual Value *CreateAnd(Constant *LHS, Constant *RHS) const = 0;
- virtual Value *CreateOr(Constant *LHS, Constant *RHS) const = 0;
- virtual Value *CreateXor(Constant *LHS, Constant *RHS) const = 0;
- virtual Value *CreateBinOp(Instruction::BinaryOps Opc,
- Constant *LHS, Constant *RHS) const = 0;
-
- //===--------------------------------------------------------------------===//
- // Unary Operators
- //===--------------------------------------------------------------------===//
-
- virtual Value *CreateNeg(Constant *C,
- bool HasNUW = false, bool HasNSW = false) const = 0;
- virtual Value *CreateFNeg(Constant *C) const = 0;
- virtual Value *CreateNot(Constant *C) const = 0;
- virtual Value *CreateUnOp(Instruction::UnaryOps Opc, Constant *C) const = 0;
-
- //===--------------------------------------------------------------------===//
- // Memory Instructions
- //===--------------------------------------------------------------------===//
-
- virtual Value *CreateGetElementPtr(Type *Ty, Constant *C,
- ArrayRef<Constant *> IdxList) const = 0;
- // This form of the function only exists to avoid ambiguous overload
- // warnings about whether to convert Idx to ArrayRef<Constant *> or
- // ArrayRef<Value *>.
- virtual Value *CreateGetElementPtr(Type *Ty, Constant *C,
- Constant *Idx) const = 0;
- virtual Value *CreateGetElementPtr(Type *Ty, Constant *C,
- ArrayRef<Value *> IdxList) const = 0;
- virtual Value *CreateInBoundsGetElementPtr(
- Type *Ty, Constant *C, ArrayRef<Constant *> IdxList) const = 0;
- // This form of the function only exists to avoid ambiguous overload
- // warnings about whether to convert Idx to ArrayRef<Constant *> or
- // ArrayRef<Value *>.
- virtual Value *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
- Constant *Idx) const = 0;
- virtual Value *CreateInBoundsGetElementPtr(
- Type *Ty, Constant *C, ArrayRef<Value *> IdxList) const = 0;
-
- //===--------------------------------------------------------------------===//
- // Cast/Conversion Operators
- //===--------------------------------------------------------------------===//
-
- virtual Value *CreateCast(Instruction::CastOps Op, Constant *C,
- Type *DestTy) const = 0;
- virtual Value *CreatePointerCast(Constant *C, Type *DestTy) const = 0;
- virtual Value *CreatePointerBitCastOrAddrSpaceCast(Constant *C,
- Type *DestTy) const = 0;
- virtual Value *CreateIntCast(Constant *C, Type *DestTy,
- bool isSigned) const = 0;
- virtual Value *CreateFPCast(Constant *C, Type *DestTy) const = 0;
- virtual Value *CreateBitCast(Constant *C, Type *DestTy) const = 0;
- virtual Value *CreateIntToPtr(Constant *C, Type *DestTy) const = 0;
- virtual Value *CreatePtrToInt(Constant *C, Type *DestTy) const = 0;
- virtual Value *CreateZExtOrBitCast(Constant *C, Type *DestTy) const = 0;
- virtual Value *CreateSExtOrBitCast(Constant *C, Type *DestTy) const = 0;
- virtual Value *CreateTruncOrBitCast(Constant *C, Type *DestTy) const = 0;
-
- //===--------------------------------------------------------------------===//
- // Compare Instructions
- //===--------------------------------------------------------------------===//
-
- virtual Value *CreateICmp(CmpInst::Predicate P, Constant *LHS,
- Constant *RHS) const = 0;
- virtual Value *CreateFCmp(CmpInst::Predicate P, Constant *LHS,
- Constant *RHS) const = 0;
-
- //===--------------------------------------------------------------------===//
- // Other Instructions
- //===--------------------------------------------------------------------===//
-
- virtual Value *CreateSelect(Constant *C, Constant *True,
- Constant *False) const = 0;
- virtual Value *CreateExtractElement(Constant *Vec, Constant *Idx) const = 0;
- virtual Value *CreateInsertElement(Constant *Vec, Constant *NewElt,
- Constant *Idx) const = 0;
- virtual Value *CreateShuffleVector(Constant *V1, Constant *V2,
- Constant *Mask) const = 0;
- virtual Value *CreateExtractValue(Constant *Agg,
- ArrayRef<unsigned> IdxList) const = 0;
- virtual Value *CreateInsertValue(Constant *Agg, Constant *Val,
- ArrayRef<unsigned> IdxList) const = 0;
-};
-
-} // end namespace llvm
-
-#endif // LLVM_IR_IRBUILDERFOLDER_H
diff --git a/llvm/include/llvm/IR/NoFolder.h b/llvm/include/llvm/IR/NoFolder.h
index 1e35cfe096eb..c03cdee1eb83 100644
--- a/llvm/include/llvm/IR/NoFolder.h
+++ b/llvm/include/llvm/IR/NoFolder.h
@@ -26,14 +26,11 @@
#include "llvm/IR/InstrTypes.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Instructions.h"
-#include "llvm/IR/IRBuilderFolder.h"
namespace llvm {
/// NoFolder - Create "constants" (actually, instructions) with no folding.
-class NoFolder final : public IRBuilderFolder {
- virtual void anchor();
-
+class NoFolder {
public:
explicit NoFolder() = default;
@@ -42,76 +39,73 @@ class NoFolder final : public IRBuilderFolder {
//===--------------------------------------------------------------------===//
Instruction *CreateAdd(Constant *LHS, Constant *RHS,
- bool HasNUW = false,
- bool HasNSW = false) const override {
+ bool HasNUW = false, bool HasNSW = false) const {
BinaryOperator *BO = BinaryOperator::CreateAdd(LHS, RHS);
if (HasNUW) BO->setHasNoUnsignedWrap();
if (HasNSW) BO->setHasNoSignedWrap();
return BO;
}
- Instruction *CreateFAdd(Constant *LHS, Constant *RHS) const override {
+ 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 override {
+ bool HasNUW = false, bool HasNSW = false) const {
BinaryOperator *BO = BinaryOperator::CreateSub(LHS, RHS);
if (HasNUW) BO->setHasNoUnsignedWrap();
if (HasNSW) BO->setHasNoSignedWrap();
return BO;
}
- Instruction *CreateFSub(Constant *LHS, Constant *RHS) const override {
+ 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 override {
+ bool HasNUW = false, bool HasNSW = false) const {
BinaryOperator *BO = BinaryOperator::CreateMul(LHS, RHS);
if (HasNUW) BO->setHasNoUnsignedWrap();
if (HasNSW) BO->setHasNoSignedWrap();
return BO;
}
- Instruction *CreateFMul(Constant *LHS, Constant *RHS) const override {
+ Instruction *CreateFMul(Constant *LHS, Constant *RHS) const {
return BinaryOperator::CreateFMul(LHS, RHS);
}
Instruction *CreateUDiv(Constant *LHS, Constant *RHS,
- bool isExact = false) const override {
+ bool isExact = false) const {
if (!isExact)
return BinaryOperator::CreateUDiv(LHS, RHS);
return BinaryOperator::CreateExactUDiv(LHS, RHS);
}
Instruction *CreateSDiv(Constant *LHS, Constant *RHS,
- bool isExact = false) const override {
+ bool isExact = false) const {
if (!isExact)
return BinaryOperator::CreateSDiv(LHS, RHS);
return BinaryOperator::CreateExactSDiv(LHS, RHS);
}
- Instruction *CreateFDiv(Constant *LHS, Constant *RHS) const override {
+ Instruction *CreateFDiv(Constant *LHS, Constant *RHS) const {
return BinaryOperator::CreateFDiv(LHS, RHS);
}
- Instruction *CreateURem(Constant *LHS, Constant *RHS) const override {
+ Instruction *CreateURem(Constant *LHS, Constant *RHS) const {
return BinaryOperator::CreateURem(LHS, RHS);
}
- Instruction *CreateSRem(Constant *LHS, Constant *RHS) const override {
+ Instruction *CreateSRem(Constant *LHS, Constant *RHS) const {
return BinaryOperator::CreateSRem(LHS, RHS);
}
- Instruction *CreateFRem(Constant *LHS, Constant *RHS) const override {
+ 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 override {
+ bool HasNSW = false) const {
BinaryOperator *BO = BinaryOperator::CreateShl(LHS, RHS);
if (HasNUW) BO->setHasNoUnsignedWrap();
if (HasNSW) BO->setHasNoSignedWrap();
@@ -119,33 +113,33 @@ class NoFolder final : public IRBuilderFolder {
}
Instruction *CreateLShr(Constant *LHS, Constant *RHS,
- bool isExact = false) const override {
+ 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 override {
+ bool isExact = false) const {
if (!isExact)
return BinaryOperator::CreateAShr(LHS, RHS);
return BinaryOperator::CreateExactAShr(LHS, RHS);
}
- Instruction *CreateAnd(Constant *LHS, Constant *RHS) const override {
+ Instruction *CreateAnd(Constant *LHS, Constant *RHS) const {
return BinaryOperator::CreateAnd(LHS, RHS);
}
- Instruction *CreateOr(Constant *LHS, Constant *RHS) const override {
+ Instruction *CreateOr(Constant *LHS, Constant *RHS) const {
return BinaryOperator::CreateOr(LHS, RHS);
}
- Instruction *CreateXor(Constant *LHS, Constant *RHS) const override {
+ Instruction *CreateXor(Constant *LHS, Constant *RHS) const {
return BinaryOperator::CreateXor(LHS, RHS);
}
Instruction *CreateBinOp(Instruction::BinaryOps Opc,
- Constant *LHS, Constant *RHS) const override {
+ Constant *LHS, Constant *RHS) const {
return BinaryOperator::Create(Opc, LHS, RHS);
}
@@ -154,24 +148,22 @@ class NoFolder final : public IRBuilderFolder {
//===--------------------------------------------------------------------===//
Instruction *CreateNeg(Constant *C,
- bool HasNUW = false,
- bool HasNSW = false) const override {
+ bool HasNUW = false, bool HasNSW = false) const {
BinaryOperator *BO = BinaryOperator::CreateNeg(C);
if (HasNUW) BO->setHasNoUnsignedWrap();
if (HasNSW) BO->setHasNoSignedWrap();
return BO;
}
- Instruction *CreateFNeg(Constant *C) const override {
+ Instruction *CreateFNeg(Constant *C) const {
return UnaryOperator::CreateFNeg(C);
}
- Instruction *CreateNot(Constant *C) const override {
+ Instruction *CreateNot(Constant *C) const {
return BinaryOperator::CreateNot(C);
}
- Instruction *CreateUnOp(Instruction::UnaryOps Opc,
- Constant *C) const override {
+ Instruction *CreateUnOp(Instruction::UnaryOps Opc, Constant *C) const {
return UnaryOperator::Create(Opc, C);
}
@@ -180,12 +172,11 @@ class NoFolder final : public IRBuilderFolder {
//===--------------------------------------------------------------------===//
Constant *CreateGetElementPtr(Type *Ty, Constant *C,
- ArrayRef<Constant *> IdxList) const override {
+ ArrayRef<Constant *> IdxList) const {
return ConstantExpr::getGetElementPtr(Ty, C, IdxList);
}
- Constant *CreateGetElementPtr(Type *Ty, Constant *C,
- Constant *Idx) const override {
+ Constant *CreateGetElementPtr(Type *Ty, Constant *C, Constant *Idx) const {
// This form of the function only exists to avoid ambiguous overload
// warnings about whether to convert Idx to ArrayRef<Constant *> or
// ArrayRef<Value *>.
@@ -193,25 +184,25 @@ class NoFolder final : public IRBuilderFolder {
}
Instruction *CreateGetElementPtr(Type *Ty, Constant *C,
- ArrayRef<Value *> IdxList) const override {
+ ArrayRef<Value *> IdxList) const {
return GetElementPtrInst::Create(Ty, C, IdxList);
}
- Constant *CreateInBoundsGetElementPtr(
- Type *Ty, Constant *C, ArrayRef<Constant *> IdxList) const override {
+ Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
+ ArrayRef<Constant *> IdxList) const {
return ConstantExpr::getInBoundsGetElementPtr(Ty, C, IdxList);
}
Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
- Constant *Idx) const override {
+ Constant *Idx) const {
// This form of the function only exists to avoid ambiguous overload
// warnings about whether to convert Idx to ArrayRef<Constant *> or
// ArrayRef<Value *>.
return ConstantExpr::getInBoundsGetElementPtr(Ty, C, Idx);
}
- Instruction *CreateInBoundsGetElementPtr(
- Type *Ty, Constant *C, ArrayRef<Value *> IdxList) const override {
+ Instruction *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
+ ArrayRef<Value *> IdxList) const {
return GetElementPtrInst::CreateInBounds(Ty, C, IdxList);
}
@@ -220,49 +211,49 @@ class NoFolder final : public IRBuilderFolder {
//===--------------------------------------------------------------------===//
Instruction *CreateCast(Instruction::CastOps Op, Constant *C,
- Type *DestTy) const override {
+ Type *DestTy) const {
return CastInst::Create(Op, C, DestTy);
}
- Instruction *CreatePointerCast(Constant *C, Type *DestTy) const override {
+ Instruction *CreatePointerCast(Constant *C, Type *DestTy) const {
return CastInst::CreatePointerCast(C, DestTy);
}
Instruction *CreatePointerBitCastOrAddrSpaceCast(
- Constant *C, Type *DestTy) const override {
+ Constant *C, Type *DestTy) const {
return CastInst::CreatePointerBitCastOrAddrSpaceCast(C, DestTy);
}
Instruction *CreateIntCast(Constant *C, Type *DestTy,
- bool isSigned) const override {
+ bool isSigned) const {
return CastInst::CreateIntegerCast(C, DestTy, isSigned);
}
- Instruction *CreateFPCast(Constant *C, Type *DestTy) const override {
+ Instruction *CreateFPCast(Constant *C, Type *DestTy) const {
return CastInst::CreateFPCast(C, DestTy);
}
- Instruction *CreateBitCast(Constant *C, Type *DestTy) const override {
+ Instruction *CreateBitCast(Constant *C, Type *DestTy) const {
return CreateCast(Instruction::BitCast, C, DestTy);
}
- Instruction *CreateIntToPtr(Constant *C, Type *DestTy) const override {
+ Instruction *CreateIntToPtr(Constant *C, Type *DestTy) const {
return CreateCast(Instruction::IntToPtr, C, DestTy);
}
- Instruction *CreatePtrToInt(Constant *C, Type *DestTy) const override {
+ Instruction *CreatePtrToInt(Constant *C, Type *DestTy) const {
return CreateCast(Instruction::PtrToInt, C, DestTy);
}
- Instruction *CreateZExtOrBitCast(Constant *C, Type *DestTy) const override {
+ Instruction *CreateZExtOrBitCast(Constant *C, Type *DestTy) const {
return CastInst::CreateZExtOrBitCast(C, DestTy);
}
- Instruction *CreateSExtOrBitCast(Constant *C, Type *DestTy) const override {
+ Instruction *CreateSExtOrBitCast(Constant *C, Type *DestTy) const {
return CastInst::CreateSExtOrBitCast(C, DestTy);
}
- Instruction *CreateTruncOrBitCast(Constant *C, Type *DestTy) const override {
+ Instruction *CreateTruncOrBitCast(Constant *C, Type *DestTy) const {
return CastInst::CreateTruncOrBitCast(C, DestTy);
}
@@ -271,12 +262,12 @@ class NoFolder final : public IRBuilderFolder {
//===--------------------------------------------------------------------===//
Instruction *CreateICmp(CmpInst::Predicate P,
- Constant *LHS, Constant *RHS) const override {
+ Constant *LHS, Constant *RHS) const {
return new ICmpInst(P, LHS, RHS);
}
Instruction *CreateFCmp(CmpInst::Predicate P,
- Constant *LHS, Constant *RHS) const override {
+ Constant *LHS, Constant *RHS) const {
return new FCmpInst(P, LHS, RHS);
}
@@ -285,32 +276,31 @@ class NoFolder final : public IRBuilderFolder {
//===--------------------------------------------------------------------===//
Instruction *CreateSelect(Constant *C,
- Constant *True, Constant *False) const override {
+ Constant *True, Constant *False) const {
return SelectInst::Create(C, True, False);
}
- Instruction *CreateExtractElement(Constant *Vec,
- Constant *Idx) const override {
+ Instruction *CreateExtractElement(Constant *Vec, Constant *Idx) const {
return ExtractElementInst::Create(Vec, Idx);
}
Instruction *CreateInsertElement(Constant *Vec, Constant *NewElt,
- Constant *Idx) const override {
+ Constant *Idx) const {
return InsertElementInst::Create(Vec, NewElt, Idx);
}
Instruction *CreateShuffleVector(Constant *V1, Constant *V2,
- Constant *Mask) const override {
+ Constant *Mask) const {
return new ShuffleVectorInst(V1, V2, Mask);
}
Instruction *CreateExtractValue(Constant *Agg,
- ArrayRef<unsigned> IdxList) const override {
+ ArrayRef<unsigned> IdxList) const {
return ExtractValueInst::Create(Agg, IdxList);
}
Instruction *CreateInsertValue(Constant *Agg, Constant *Val,
- ArrayRef<unsigned> IdxList) const override {
+ ArrayRef<unsigned> IdxList) const {
return InsertValueInst::Create(Agg, Val, IdxList);
}
};
diff --git a/llvm/lib/Analysis/ConstantFolding.cpp b/llvm/lib/Analysis/ConstantFolding.cpp
index 059bf9a53275..0e4828d912dc 100644
--- a/llvm/lib/Analysis/ConstantFolding.cpp
+++ b/llvm/lib/Analysis/ConstantFolding.cpp
@@ -23,7 +23,6 @@
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
-#include "llvm/Analysis/TargetFolder.h"
#include "llvm/Analysis/TargetLibraryInfo.h"
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/Analysis/VectorUtils.h"
@@ -2661,5 +2660,3 @@ bool llvm::isMathLibCallNoop(const CallBase *Call,
return false;
}
-
-void TargetFolder::anchor() {}
diff --git a/llvm/lib/IR/IRBuilder.cpp b/llvm/lib/IR/IRBuilder.cpp
index 457255b157cc..0dd78f2f2d4b 100644
--- a/llvm/lib/IR/IRBuilder.cpp
+++ b/llvm/lib/IR/IRBuilder.cpp
@@ -24,7 +24,6 @@
#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Operator.h"
-#include "llvm/IR/NoFolder.h"
#include "llvm/IR/Statepoint.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/Value.h"
@@ -785,9 +784,3 @@ CallInst *IRBuilderBase::CreateIntrinsic(Intrinsic::ID ID,
Function *Fn = Intrinsic::getDeclaration(M, ID, Types);
return createCallHelper(Fn, Args, this, Name, FMFSource);
}
-
-IRBuilderDefaultInserter::~IRBuilderDefaultInserter() {}
-IRBuilderCallbackInserter::~IRBuilderCallbackInserter() {}
-IRBuilderFolder::~IRBuilderFolder() {}
-void ConstantFolder::anchor() {}
-void NoFolder::anchor() {}
diff --git a/llvm/lib/Transforms/Scalar/SROA.cpp b/llvm/lib/Transforms/Scalar/SROA.cpp
index 9bbc06eb95b8..6c9b62da5e79 100644
--- a/llvm/lib/Transforms/Scalar/SROA.cpp
+++ b/llvm/lib/Transforms/Scalar/SROA.cpp
@@ -129,7 +129,7 @@ namespace {
/// A custom IRBuilder inserter which prefixes all names, but only in
/// Assert builds.
-class IRBuilderPrefixedInserter final : public IRBuilderDefaultInserter {
+class IRBuilderPrefixedInserter : public IRBuilderDefaultInserter {
std::string Prefix;
const Twine getNameWithPrefix(const Twine &Name) const {
@@ -139,8 +139,9 @@ class IRBuilderPrefixedInserter final : public IRBuilderDefaultInserter {
public:
void SetNamePrefix(const Twine &P) { Prefix = P.str(); }
+protected:
void InsertHelper(Instruction *I, const Twine &Name, BasicBlock *BB,
- BasicBlock::iterator InsertPt) const override {
+ BasicBlock::iterator InsertPt) const {
IRBuilderDefaultInserter::InsertHelper(I, getNameWithPrefix(Name), BB,
InsertPt);
}
@@ -2367,8 +2368,7 @@ class llvm::sroa::AllocaSliceRewriter
Instruction *OldUserI = cast<Instruction>(OldUse->getUser());
IRB.SetInsertPoint(OldUserI);
IRB.SetCurrentDebugLocation(OldUserI->getDebugLoc());
- IRB.getInserter().SetNamePrefix(
- Twine(NewAI.getName()) + "." + Twine(BeginOffset) + ".");
+ IRB.SetNamePrefix(Twine(NewAI.getName()) + "." + Twine(BeginOffset) + ".");
CanSROA &= visit(cast<Instruction>(OldUse->getUser()));
if (VecTy || IntTy)
diff --git a/polly/include/polly/CodeGen/IRBuilder.h b/polly/include/polly/CodeGen/IRBuilder.h
index 664da464868b..8033ffafb7de 100644
--- a/polly/include/polly/CodeGen/IRBuilder.h
+++ b/polly/include/polly/CodeGen/IRBuilder.h
@@ -131,14 +131,15 @@ class ScopAnnotator {
///
/// This is used to add additional items such as e.g. the llvm.loop.parallel
/// metadata.
-class IRInserter final : public llvm::IRBuilderDefaultInserter {
+class IRInserter : protected llvm::IRBuilderDefaultInserter {
public:
IRInserter() = default;
IRInserter(class ScopAnnotator &A) : Annotator(&A) {}
+protected:
void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name,
llvm::BasicBlock *BB,
- llvm::BasicBlock::iterator InsertPt) const override {
+ llvm::BasicBlock::iterator InsertPt) const {
llvm::IRBuilderDefaultInserter::InsertHelper(I, Name, BB, InsertPt);
if (Annotator)
Annotator->annotate(I);
More information about the llvm-commits
mailing list