mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-10-20 09:24:58 +00:00
Make it possible to use different constant
folding policies with IRBuilder. The default, provided by ConstantFolder, is to do minimal folding like now: what ConstantExpr provides. An alternative is to use TargetFolder, which uses target information to fold constants more. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@54640 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
4630e4ddcf
commit
1e7f7865eb
175
include/llvm/Support/ConstantFolder.h
Normal file
175
include/llvm/Support/ConstantFolder.h
Normal file
@ -0,0 +1,175 @@
|
|||||||
|
//===-- llvm/Support/ConstantFolder.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 ConstantFolder class, which provides a set of methods
|
||||||
|
// for creating constants, with minimal folding.
|
||||||
|
//
|
||||||
|
//===----------------------------------------------------------------------===//
|
||||||
|
|
||||||
|
#ifndef LLVM_SUPPORT_CONSTANTFOLDER_H
|
||||||
|
#define LLVM_SUPPORT_CONSTANTFOLDER_H
|
||||||
|
|
||||||
|
#include "llvm/Constants.h"
|
||||||
|
|
||||||
|
namespace llvm {
|
||||||
|
|
||||||
|
/// ConstantFolder - Create constants with minimum, target independent, folding.
|
||||||
|
class ConstantFolder {
|
||||||
|
public:
|
||||||
|
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
// Binary Operators
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
|
||||||
|
Constant *CreateAdd(Constant *LHS, Constant *RHS) const {
|
||||||
|
return ConstantExpr::getAdd(LHS, RHS);
|
||||||
|
}
|
||||||
|
Constant *CreateSub(Constant *LHS, Constant *RHS) const {
|
||||||
|
return ConstantExpr::getSub(LHS, RHS);
|
||||||
|
}
|
||||||
|
Constant *CreateMul(Constant *LHS, Constant *RHS) const {
|
||||||
|
return ConstantExpr::getMul(LHS, RHS);
|
||||||
|
}
|
||||||
|
Constant *CreateUDiv(Constant *LHS, Constant *RHS) const {
|
||||||
|
return ConstantExpr::getUDiv(LHS, RHS);
|
||||||
|
}
|
||||||
|
Constant *CreateSDiv(Constant *LHS, Constant *RHS) const {
|
||||||
|
return ConstantExpr::getSDiv(LHS, RHS);
|
||||||
|
}
|
||||||
|
Constant *CreateFDiv(Constant *LHS, Constant *RHS) const {
|
||||||
|
return ConstantExpr::getFDiv(LHS, RHS);
|
||||||
|
}
|
||||||
|
Constant *CreateURem(Constant *LHS, Constant *RHS) const {
|
||||||
|
return ConstantExpr::getURem(LHS, RHS);
|
||||||
|
}
|
||||||
|
Constant *CreateSRem(Constant *LHS, Constant *RHS) const {
|
||||||
|
return ConstantExpr::getSRem(LHS, RHS);
|
||||||
|
}
|
||||||
|
Constant *CreateFRem(Constant *LHS, Constant *RHS) const {
|
||||||
|
return ConstantExpr::getFRem(LHS, RHS);
|
||||||
|
}
|
||||||
|
Constant *CreateShl(Constant *LHS, Constant *RHS) const {
|
||||||
|
return ConstantExpr::getShl(LHS, RHS);
|
||||||
|
}
|
||||||
|
Constant *CreateLShr(Constant *LHS, Constant *RHS) const {
|
||||||
|
return ConstantExpr::getLShr(LHS, RHS);
|
||||||
|
}
|
||||||
|
Constant *CreateAShr(Constant *LHS, Constant *RHS) const {
|
||||||
|
return ConstantExpr::getAShr(LHS, RHS);
|
||||||
|
}
|
||||||
|
Constant *CreateAnd(Constant *LHS, Constant *RHS) const {
|
||||||
|
return ConstantExpr::getAnd(LHS, RHS);
|
||||||
|
}
|
||||||
|
Constant *CreateOr(Constant *LHS, Constant *RHS) const {
|
||||||
|
return ConstantExpr::getOr(LHS, RHS);
|
||||||
|
}
|
||||||
|
Constant *CreateXor(Constant *LHS, Constant *RHS) const {
|
||||||
|
return ConstantExpr::getXor(LHS, RHS);
|
||||||
|
}
|
||||||
|
|
||||||
|
Constant *CreateBinOp(Instruction::BinaryOps Opc,
|
||||||
|
Constant *LHS, Constant *RHS) const {
|
||||||
|
return ConstantExpr::get(Opc, LHS, RHS);
|
||||||
|
}
|
||||||
|
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
// Unary Operators
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
|
||||||
|
Constant *CreateNeg(Constant *C) const {
|
||||||
|
return ConstantExpr::getNeg(C);
|
||||||
|
}
|
||||||
|
Constant *CreateNot(Constant *C) const {
|
||||||
|
return ConstantExpr::getNot(C);
|
||||||
|
}
|
||||||
|
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
// Memory Instructions
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
|
||||||
|
Constant *CreateGetElementPtr(Constant *C, Constant* const *IdxList,
|
||||||
|
unsigned NumIdx) const {
|
||||||
|
return ConstantExpr::getGetElementPtr(C, IdxList, NumIdx);
|
||||||
|
}
|
||||||
|
Constant *CreateGetElementPtr(Constant *C, Value* const *IdxList,
|
||||||
|
unsigned NumIdx) const {
|
||||||
|
return ConstantExpr::getGetElementPtr(C, IdxList, NumIdx);
|
||||||
|
}
|
||||||
|
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
// Cast/Conversion Operators
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
|
||||||
|
Constant *CreateCast(Instruction::CastOps Op, Constant *C,
|
||||||
|
const Type *DestTy) const {
|
||||||
|
return ConstantExpr::getCast(Op, C, DestTy);
|
||||||
|
}
|
||||||
|
Constant *CreateIntCast(Constant *C, const Type *DestTy,
|
||||||
|
bool isSigned) const {
|
||||||
|
return ConstantExpr::getIntegerCast(C, DestTy, isSigned);
|
||||||
|
}
|
||||||
|
|
||||||
|
Constant *CreateBitCast(Constant *C, const Type *DestTy) const {
|
||||||
|
return CreateCast(Instruction::BitCast, C, DestTy);
|
||||||
|
}
|
||||||
|
Constant *CreateIntToPtr(Constant *C, const Type *DestTy) const {
|
||||||
|
return CreateCast(Instruction::IntToPtr, C, DestTy);
|
||||||
|
}
|
||||||
|
Constant *CreatePtrToInt(Constant *C, const Type *DestTy) const {
|
||||||
|
return CreateCast(Instruction::PtrToInt, C, DestTy);
|
||||||
|
}
|
||||||
|
Constant *CreateTruncOrBitCast(Constant *C, const Type *DestTy) const {
|
||||||
|
return ConstantExpr::getTruncOrBitCast(C, DestTy);
|
||||||
|
}
|
||||||
|
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
// Compare Instructions
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
|
||||||
|
Constant *CreateCompare(CmpInst::Predicate P, Constant *LHS,
|
||||||
|
Constant *RHS) const {
|
||||||
|
return ConstantExpr::getCompare(P, LHS, RHS);
|
||||||
|
}
|
||||||
|
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
// Other Instructions
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
|
||||||
|
Constant *CreateSelect(Constant *C, Constant *True, Constant *False) const {
|
||||||
|
return ConstantExpr::getSelect(C, True, False);
|
||||||
|
}
|
||||||
|
|
||||||
|
Constant *CreateExtractElement(Constant *Vec, Constant *Idx) const {
|
||||||
|
return ConstantExpr::getExtractElement(Vec, Idx);
|
||||||
|
}
|
||||||
|
|
||||||
|
Constant *CreateInsertElement(Constant *Vec, Constant *NewElt,
|
||||||
|
Constant *Idx) const {
|
||||||
|
return ConstantExpr::getInsertElement(Vec, NewElt, Idx);
|
||||||
|
}
|
||||||
|
|
||||||
|
Constant *CreateShuffleVector(Constant *V1, Constant *V2,
|
||||||
|
Constant *Mask) const {
|
||||||
|
return ConstantExpr::getShuffleVector(V1, V2, Mask);
|
||||||
|
}
|
||||||
|
|
||||||
|
Constant *CreateExtractValue(Constant *Agg, const unsigned *IdxList,
|
||||||
|
unsigned NumIdx) const {
|
||||||
|
return ConstantExpr::getExtractValue(Agg, IdxList, NumIdx);
|
||||||
|
}
|
||||||
|
|
||||||
|
Constant *CreateInsertValue(Constant *Agg, Constant *Val,
|
||||||
|
const unsigned *IdxList, unsigned NumIdx) const {
|
||||||
|
return ConstantExpr::getInsertValue(Agg, Val, IdxList, NumIdx);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
@ -16,15 +16,16 @@
|
|||||||
#define LLVM_SUPPORT_IRBUILDER_H
|
#define LLVM_SUPPORT_IRBUILDER_H
|
||||||
|
|
||||||
#include "llvm/BasicBlock.h"
|
#include "llvm/BasicBlock.h"
|
||||||
#include "llvm/Instructions.h"
|
|
||||||
#include "llvm/Constants.h"
|
#include "llvm/Constants.h"
|
||||||
|
#include "llvm/Instructions.h"
|
||||||
#include "llvm/GlobalVariable.h"
|
#include "llvm/GlobalVariable.h"
|
||||||
#include "llvm/Function.h"
|
#include "llvm/Function.h"
|
||||||
|
#include "llvm/Support/ConstantFolder.h"
|
||||||
|
|
||||||
namespace llvm {
|
namespace llvm {
|
||||||
|
|
||||||
/// IRBuilder - This provides a uniform API for creating instructions and
|
/// IRBuilder - This provides a uniform API for creating instructions and
|
||||||
/// inserting them into a basic block: either at the end of a BasicBlock, or
|
/// inserting them into a basic block: either at the end of a BasicBlock, or
|
||||||
/// at a specific iterator location in a block.
|
/// at a specific iterator location in a block.
|
||||||
///
|
///
|
||||||
/// Note that the builder does not expose the full generality of LLVM
|
/// Note that the builder does not expose the full generality of LLVM
|
||||||
@ -33,17 +34,23 @@ namespace llvm {
|
|||||||
/// supports nul-terminated C strings. For fully generic names, use
|
/// supports nul-terminated C strings. For fully generic names, use
|
||||||
/// I->setName(). For access to extra instruction properties, use the mutators
|
/// I->setName(). For access to extra instruction properties, use the mutators
|
||||||
/// (e.g. setVolatile) on the instructions after they have been created.
|
/// (e.g. setVolatile) on the instructions after they have been created.
|
||||||
/// The template argument handles whether or not to preserve names in the final
|
/// The first template argument handles whether or not to preserve names in the
|
||||||
/// instruction output. This defaults to on.
|
/// final instruction output. This defaults to on. The second template argument
|
||||||
template <bool preserveNames=true> class IRBuilder {
|
/// specifies a class to use for creating constants. This defaults to creating
|
||||||
|
/// minimally folded constants.
|
||||||
|
template <bool preserveNames=true, typename T = ConstantFolder> class IRBuilder{
|
||||||
BasicBlock *BB;
|
BasicBlock *BB;
|
||||||
BasicBlock::iterator InsertPt;
|
BasicBlock::iterator InsertPt;
|
||||||
|
T Folder;
|
||||||
public:
|
public:
|
||||||
IRBuilder() { ClearInsertionPoint(); }
|
IRBuilder(const T& F = T()) : Folder(F) { ClearInsertionPoint(); }
|
||||||
explicit IRBuilder(BasicBlock *TheBB) { SetInsertPoint(TheBB); }
|
explicit IRBuilder(BasicBlock *TheBB, const T& F = T())
|
||||||
IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP) {
|
: Folder(F) { SetInsertPoint(TheBB); }
|
||||||
SetInsertPoint(TheBB, IP);
|
IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, const T& F = T())
|
||||||
}
|
: Folder(F) { SetInsertPoint(TheBB, IP); }
|
||||||
|
|
||||||
|
/// getFolder - Get the constant folder being used.
|
||||||
|
const T& getFolder() { return Folder; }
|
||||||
|
|
||||||
//===--------------------------------------------------------------------===//
|
//===--------------------------------------------------------------------===//
|
||||||
// Builder configuration methods
|
// Builder configuration methods
|
||||||
@ -54,30 +61,30 @@ public:
|
|||||||
void ClearInsertionPoint() {
|
void ClearInsertionPoint() {
|
||||||
BB = 0;
|
BB = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
BasicBlock *GetInsertBlock() const { return BB; }
|
BasicBlock *GetInsertBlock() const { return BB; }
|
||||||
|
|
||||||
/// SetInsertPoint - This specifies that created instructions should be
|
/// SetInsertPoint - This specifies that created instructions should be
|
||||||
/// appended to the end of the specified block.
|
/// appended to the end of the specified block.
|
||||||
void SetInsertPoint(BasicBlock *TheBB) {
|
void SetInsertPoint(BasicBlock *TheBB) {
|
||||||
BB = TheBB;
|
BB = TheBB;
|
||||||
InsertPt = BB->end();
|
InsertPt = BB->end();
|
||||||
}
|
}
|
||||||
|
|
||||||
/// SetInsertPoint - This specifies that created instructions should be
|
/// SetInsertPoint - This specifies that created instructions should be
|
||||||
/// inserted at the specified point.
|
/// inserted at the specified point.
|
||||||
void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) {
|
void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) {
|
||||||
BB = TheBB;
|
BB = TheBB;
|
||||||
InsertPt = IP;
|
InsertPt = IP;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Insert - Insert and return the specified instruction.
|
/// Insert - Insert and return the specified instruction.
|
||||||
template<typename InstTy>
|
template<typename InstTy>
|
||||||
InstTy *Insert(InstTy *I, const char *Name = "") const {
|
InstTy *Insert(InstTy *I, const char *Name = "") const {
|
||||||
InsertHelper(I, Name);
|
InsertHelper(I, Name);
|
||||||
return I;
|
return I;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// InsertHelper - Insert the specified instruction at the specified insertion
|
/// InsertHelper - Insert the specified instruction at the specified insertion
|
||||||
/// point. This is split out of Insert so that it isn't duplicated for every
|
/// point. This is split out of Insert so that it isn't duplicated for every
|
||||||
/// template instantiation.
|
/// template instantiation.
|
||||||
@ -86,7 +93,7 @@ public:
|
|||||||
if (preserveNames && Name[0])
|
if (preserveNames && Name[0])
|
||||||
I->setName(Name);
|
I->setName(Name);
|
||||||
}
|
}
|
||||||
|
|
||||||
//===--------------------------------------------------------------------===//
|
//===--------------------------------------------------------------------===//
|
||||||
// Instruction creation methods: Terminators
|
// Instruction creation methods: Terminators
|
||||||
//===--------------------------------------------------------------------===//
|
//===--------------------------------------------------------------------===//
|
||||||
@ -96,8 +103,8 @@ public:
|
|||||||
return Insert(ReturnInst::Create());
|
return Insert(ReturnInst::Create());
|
||||||
}
|
}
|
||||||
|
|
||||||
/// @verbatim
|
/// @verbatim
|
||||||
/// CreateRet - Create a 'ret <val>' instruction.
|
/// CreateRet - Create a 'ret <val>' instruction.
|
||||||
/// @endverbatim
|
/// @endverbatim
|
||||||
ReturnInst *CreateRet(Value *V) {
|
ReturnInst *CreateRet(Value *V) {
|
||||||
return Insert(ReturnInst::Create(V));
|
return Insert(ReturnInst::Create(V));
|
||||||
@ -117,7 +124,7 @@ public:
|
|||||||
V = CreateInsertValue(V, retVals[i], i, "mrv");
|
V = CreateInsertValue(V, retVals[i], i, "mrv");
|
||||||
return Insert(ReturnInst::Create(V));
|
return Insert(ReturnInst::Create(V));
|
||||||
}
|
}
|
||||||
|
|
||||||
/// CreateBr - Create an unconditional 'br label X' instruction.
|
/// CreateBr - Create an unconditional 'br label X' instruction.
|
||||||
BranchInst *CreateBr(BasicBlock *Dest) {
|
BranchInst *CreateBr(BasicBlock *Dest) {
|
||||||
return Insert(BranchInst::Create(Dest));
|
return Insert(BranchInst::Create(Dest));
|
||||||
@ -128,23 +135,23 @@ public:
|
|||||||
BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False) {
|
BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False) {
|
||||||
return Insert(BranchInst::Create(True, False, Cond));
|
return Insert(BranchInst::Create(True, False, Cond));
|
||||||
}
|
}
|
||||||
|
|
||||||
/// CreateSwitch - Create a switch instruction with the specified value,
|
/// CreateSwitch - Create a switch instruction with the specified value,
|
||||||
/// default dest, and with a hint for the number of cases that will be added
|
/// default dest, and with a hint for the number of cases that will be added
|
||||||
/// (for efficient allocation).
|
/// (for efficient allocation).
|
||||||
SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10) {
|
SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10) {
|
||||||
return Insert(SwitchInst::Create(V, Dest, NumCases));
|
return Insert(SwitchInst::Create(V, Dest, NumCases));
|
||||||
}
|
}
|
||||||
|
|
||||||
/// CreateInvoke - Create an invoke instruction.
|
/// CreateInvoke - Create an invoke instruction.
|
||||||
template<typename InputIterator>
|
template<typename InputIterator>
|
||||||
InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest,
|
InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest,
|
||||||
BasicBlock *UnwindDest, InputIterator ArgBegin,
|
BasicBlock *UnwindDest, InputIterator ArgBegin,
|
||||||
InputIterator ArgEnd, const char *Name = "") {
|
InputIterator ArgEnd, const char *Name = "") {
|
||||||
return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest,
|
return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest,
|
||||||
ArgBegin, ArgEnd), Name);
|
ArgBegin, ArgEnd), Name);
|
||||||
}
|
}
|
||||||
|
|
||||||
UnwindInst *CreateUnwind() {
|
UnwindInst *CreateUnwind() {
|
||||||
return Insert(new UnwindInst());
|
return Insert(new UnwindInst());
|
||||||
}
|
}
|
||||||
@ -152,7 +159,7 @@ public:
|
|||||||
UnreachableInst *CreateUnreachable() {
|
UnreachableInst *CreateUnreachable() {
|
||||||
return Insert(new UnreachableInst());
|
return Insert(new UnreachableInst());
|
||||||
}
|
}
|
||||||
|
|
||||||
//===--------------------------------------------------------------------===//
|
//===--------------------------------------------------------------------===//
|
||||||
// Instruction creation methods: Binary Operators
|
// Instruction creation methods: Binary Operators
|
||||||
//===--------------------------------------------------------------------===//
|
//===--------------------------------------------------------------------===//
|
||||||
@ -160,91 +167,91 @@ public:
|
|||||||
Value *CreateAdd(Value *LHS, Value *RHS, const char *Name = "") {
|
Value *CreateAdd(Value *LHS, Value *RHS, const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::getAdd(LC, RC);
|
return Folder.CreateAdd(LC, RC);
|
||||||
return Insert(BinaryOperator::CreateAdd(LHS, RHS), Name);
|
return Insert(BinaryOperator::CreateAdd(LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
Value *CreateSub(Value *LHS, Value *RHS, const char *Name = "") {
|
Value *CreateSub(Value *LHS, Value *RHS, const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::getSub(LC, RC);
|
return Folder.CreateSub(LC, RC);
|
||||||
return Insert(BinaryOperator::CreateSub(LHS, RHS), Name);
|
return Insert(BinaryOperator::CreateSub(LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
Value *CreateMul(Value *LHS, Value *RHS, const char *Name = "") {
|
Value *CreateMul(Value *LHS, Value *RHS, const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::getMul(LC, RC);
|
return Folder.CreateMul(LC, RC);
|
||||||
return Insert(BinaryOperator::CreateMul(LHS, RHS), Name);
|
return Insert(BinaryOperator::CreateMul(LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
Value *CreateUDiv(Value *LHS, Value *RHS, const char *Name = "") {
|
Value *CreateUDiv(Value *LHS, Value *RHS, const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::getUDiv(LC, RC);
|
return Folder.CreateUDiv(LC, RC);
|
||||||
return Insert(BinaryOperator::CreateUDiv(LHS, RHS), Name);
|
return Insert(BinaryOperator::CreateUDiv(LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
Value *CreateSDiv(Value *LHS, Value *RHS, const char *Name = "") {
|
Value *CreateSDiv(Value *LHS, Value *RHS, const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::getSDiv(LC, RC);
|
return Folder.CreateSDiv(LC, RC);
|
||||||
return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name);
|
return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
Value *CreateFDiv(Value *LHS, Value *RHS, const char *Name = "") {
|
Value *CreateFDiv(Value *LHS, Value *RHS, const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::getFDiv(LC, RC);
|
return Folder.CreateFDiv(LC, RC);
|
||||||
return Insert(BinaryOperator::CreateFDiv(LHS, RHS), Name);
|
return Insert(BinaryOperator::CreateFDiv(LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
Value *CreateURem(Value *LHS, Value *RHS, const char *Name = "") {
|
Value *CreateURem(Value *LHS, Value *RHS, const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::getURem(LC, RC);
|
return Folder.CreateURem(LC, RC);
|
||||||
return Insert(BinaryOperator::CreateURem(LHS, RHS), Name);
|
return Insert(BinaryOperator::CreateURem(LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
Value *CreateSRem(Value *LHS, Value *RHS, const char *Name = "") {
|
Value *CreateSRem(Value *LHS, Value *RHS, const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::getSRem(LC, RC);
|
return Folder.CreateSRem(LC, RC);
|
||||||
return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name);
|
return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
Value *CreateFRem(Value *LHS, Value *RHS, const char *Name = "") {
|
Value *CreateFRem(Value *LHS, Value *RHS, const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::getFRem(LC, RC);
|
return Folder.CreateFRem(LC, RC);
|
||||||
return Insert(BinaryOperator::CreateFRem(LHS, RHS), Name);
|
return Insert(BinaryOperator::CreateFRem(LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
Value *CreateShl(Value *LHS, Value *RHS, const char *Name = "") {
|
Value *CreateShl(Value *LHS, Value *RHS, const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::getShl(LC, RC);
|
return Folder.CreateShl(LC, RC);
|
||||||
return Insert(BinaryOperator::CreateShl(LHS, RHS), Name);
|
return Insert(BinaryOperator::CreateShl(LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
Value *CreateLShr(Value *LHS, Value *RHS, const char *Name = "") {
|
Value *CreateLShr(Value *LHS, Value *RHS, const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::getLShr(LC, RC);
|
return Folder.CreateLShr(LC, RC);
|
||||||
return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name);
|
return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
Value *CreateAShr(Value *LHS, Value *RHS, const char *Name = "") {
|
Value *CreateAShr(Value *LHS, Value *RHS, const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::getAShr(LC, RC);
|
return Folder.CreateAShr(LC, RC);
|
||||||
return Insert(BinaryOperator::CreateAShr(LHS, RHS), Name);
|
return Insert(BinaryOperator::CreateAShr(LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
Value *CreateAnd(Value *LHS, Value *RHS, const char *Name = "") {
|
Value *CreateAnd(Value *LHS, Value *RHS, const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::getAnd(LC, RC);
|
return Folder.CreateAnd(LC, RC);
|
||||||
return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name);
|
return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
Value *CreateOr(Value *LHS, Value *RHS, const char *Name = "") {
|
Value *CreateOr(Value *LHS, Value *RHS, const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::getOr(LC, RC);
|
return Folder.CreateOr(LC, RC);
|
||||||
return Insert(BinaryOperator::CreateOr(LHS, RHS), Name);
|
return Insert(BinaryOperator::CreateOr(LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
Value *CreateXor(Value *LHS, Value *RHS, const char *Name = "") {
|
Value *CreateXor(Value *LHS, Value *RHS, const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::getXor(LC, RC);
|
return Folder.CreateXor(LC, RC);
|
||||||
return Insert(BinaryOperator::CreateXor(LHS, RHS), Name);
|
return Insert(BinaryOperator::CreateXor(LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -252,25 +259,25 @@ public:
|
|||||||
Value *LHS, Value *RHS, const char *Name = "") {
|
Value *LHS, Value *RHS, const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::get(Opc, LC, RC);
|
return Folder.CreateBinOp(Opc, LC, RC);
|
||||||
return Insert(BinaryOperator::Create(Opc, LHS, RHS), Name);
|
return Insert(BinaryOperator::Create(Opc, LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
|
|
||||||
Value *CreateNeg(Value *V, const char *Name = "") {
|
Value *CreateNeg(Value *V, const char *Name = "") {
|
||||||
if (Constant *VC = dyn_cast<Constant>(V))
|
if (Constant *VC = dyn_cast<Constant>(V))
|
||||||
return ConstantExpr::getNeg(VC);
|
return Folder.CreateNeg(VC);
|
||||||
return Insert(BinaryOperator::CreateNeg(V), Name);
|
return Insert(BinaryOperator::CreateNeg(V), Name);
|
||||||
}
|
}
|
||||||
Value *CreateNot(Value *V, const char *Name = "") {
|
Value *CreateNot(Value *V, const char *Name = "") {
|
||||||
if (Constant *VC = dyn_cast<Constant>(V))
|
if (Constant *VC = dyn_cast<Constant>(V))
|
||||||
return ConstantExpr::getNot(VC);
|
return Folder.CreateNot(VC);
|
||||||
return Insert(BinaryOperator::CreateNot(V), Name);
|
return Insert(BinaryOperator::CreateNot(V), Name);
|
||||||
}
|
}
|
||||||
|
|
||||||
//===--------------------------------------------------------------------===//
|
//===--------------------------------------------------------------------===//
|
||||||
// Instruction creation methods: Memory Instructions
|
// Instruction creation methods: Memory Instructions
|
||||||
//===--------------------------------------------------------------------===//
|
//===--------------------------------------------------------------------===//
|
||||||
|
|
||||||
MallocInst *CreateMalloc(const Type *Ty, Value *ArraySize = 0,
|
MallocInst *CreateMalloc(const Type *Ty, Value *ArraySize = 0,
|
||||||
const char *Name = "") {
|
const char *Name = "") {
|
||||||
return Insert(new MallocInst(Ty, ArraySize), Name);
|
return Insert(new MallocInst(Ty, ArraySize), Name);
|
||||||
@ -292,9 +299,9 @@ public:
|
|||||||
return Insert(new StoreInst(Val, Ptr, isVolatile));
|
return Insert(new StoreInst(Val, Ptr, isVolatile));
|
||||||
}
|
}
|
||||||
template<typename InputIterator>
|
template<typename InputIterator>
|
||||||
Value *CreateGEP(Value *Ptr, InputIterator IdxBegin,
|
Value *CreateGEP(Value *Ptr, InputIterator IdxBegin,
|
||||||
InputIterator IdxEnd, const char *Name = "") {
|
InputIterator IdxEnd, const char *Name = "") {
|
||||||
|
|
||||||
if (Constant *PC = dyn_cast<Constant>(Ptr)) {
|
if (Constant *PC = dyn_cast<Constant>(Ptr)) {
|
||||||
// Every index must be constant.
|
// Every index must be constant.
|
||||||
InputIterator i;
|
InputIterator i;
|
||||||
@ -303,15 +310,14 @@ public:
|
|||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
if (i == IdxEnd)
|
if (i == IdxEnd)
|
||||||
return ConstantExpr::getGetElementPtr(PC, &IdxBegin[0],
|
return Folder.CreateGetElementPtr(PC, &IdxBegin[0], IdxEnd - IdxBegin);
|
||||||
IdxEnd - IdxBegin);
|
}
|
||||||
}
|
|
||||||
return Insert(GetElementPtrInst::Create(Ptr, IdxBegin, IdxEnd), Name);
|
return Insert(GetElementPtrInst::Create(Ptr, IdxBegin, IdxEnd), Name);
|
||||||
}
|
}
|
||||||
Value *CreateGEP(Value *Ptr, Value *Idx, const char *Name = "") {
|
Value *CreateGEP(Value *Ptr, Value *Idx, const char *Name = "") {
|
||||||
if (Constant *PC = dyn_cast<Constant>(Ptr))
|
if (Constant *PC = dyn_cast<Constant>(Ptr))
|
||||||
if (Constant *IC = dyn_cast<Constant>(Idx))
|
if (Constant *IC = dyn_cast<Constant>(Idx))
|
||||||
return ConstantExpr::getGetElementPtr(PC, &IC, 1);
|
return Folder.CreateGetElementPtr(PC, &IC, 1);
|
||||||
return Insert(GetElementPtrInst::Create(Ptr, Idx), Name);
|
return Insert(GetElementPtrInst::Create(Ptr, Idx), Name);
|
||||||
}
|
}
|
||||||
Value *CreateStructGEP(Value *Ptr, unsigned Idx, const char *Name = "") {
|
Value *CreateStructGEP(Value *Ptr, unsigned Idx, const char *Name = "") {
|
||||||
@ -319,16 +325,16 @@ public:
|
|||||||
ConstantInt::get(llvm::Type::Int32Ty, 0),
|
ConstantInt::get(llvm::Type::Int32Ty, 0),
|
||||||
ConstantInt::get(llvm::Type::Int32Ty, Idx)
|
ConstantInt::get(llvm::Type::Int32Ty, Idx)
|
||||||
};
|
};
|
||||||
|
|
||||||
if (Constant *PC = dyn_cast<Constant>(Ptr))
|
if (Constant *PC = dyn_cast<Constant>(Ptr))
|
||||||
return ConstantExpr::getGetElementPtr(PC, Idxs, 2);
|
return Folder.CreateGetElementPtr(PC, Idxs, 2);
|
||||||
|
|
||||||
return Insert(GetElementPtrInst::Create(Ptr, Idxs, Idxs+2), Name);
|
return Insert(GetElementPtrInst::Create(Ptr, Idxs, Idxs+2), Name);
|
||||||
}
|
}
|
||||||
Value *CreateGlobalString(const char *Str = "", const char *Name = "") {
|
Value *CreateGlobalString(const char *Str = "", const char *Name = "") {
|
||||||
Constant *StrConstant = ConstantArray::get(Str, true);
|
Constant *StrConstant = ConstantArray::get(Str, true);
|
||||||
GlobalVariable *gv = new llvm::GlobalVariable(StrConstant->getType(),
|
GlobalVariable *gv = new llvm::GlobalVariable(StrConstant->getType(),
|
||||||
true,
|
true,
|
||||||
GlobalValue::InternalLinkage,
|
GlobalValue::InternalLinkage,
|
||||||
StrConstant,
|
StrConstant,
|
||||||
"",
|
"",
|
||||||
@ -341,12 +347,12 @@ public:
|
|||||||
Value *gv = CreateGlobalString(Str, Name);
|
Value *gv = CreateGlobalString(Str, Name);
|
||||||
Value *zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
|
Value *zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
|
||||||
Value *Args[] = { zero, zero };
|
Value *Args[] = { zero, zero };
|
||||||
return CreateGEP(gv, Args, Args+2, Name);
|
return CreateGEP(gv, Args, Args+2, Name);
|
||||||
}
|
}
|
||||||
//===--------------------------------------------------------------------===//
|
//===--------------------------------------------------------------------===//
|
||||||
// Instruction creation methods: Cast/Conversion Operators
|
// Instruction creation methods: Cast/Conversion Operators
|
||||||
//===--------------------------------------------------------------------===//
|
//===--------------------------------------------------------------------===//
|
||||||
|
|
||||||
Value *CreateTrunc(Value *V, const Type *DestTy, const char *Name = "") {
|
Value *CreateTrunc(Value *V, const Type *DestTy, const char *Name = "") {
|
||||||
return CreateCast(Instruction::Trunc, V, DestTy, Name);
|
return CreateCast(Instruction::Trunc, V, DestTy, Name);
|
||||||
}
|
}
|
||||||
@ -393,7 +399,7 @@ public:
|
|||||||
if (V->getType() == DestTy)
|
if (V->getType() == DestTy)
|
||||||
return V;
|
return V;
|
||||||
if (Constant *VC = dyn_cast<Constant>(V))
|
if (Constant *VC = dyn_cast<Constant>(V))
|
||||||
return ConstantExpr::getCast(Op, VC, DestTy);
|
return Folder.CreateCast(Op, VC, DestTy);
|
||||||
return Insert(CastInst::Create(Op, V, DestTy), Name);
|
return Insert(CastInst::Create(Op, V, DestTy), Name);
|
||||||
}
|
}
|
||||||
Value *CreateIntCast(Value *V, const Type *DestTy, bool isSigned,
|
Value *CreateIntCast(Value *V, const Type *DestTy, bool isSigned,
|
||||||
@ -401,14 +407,14 @@ public:
|
|||||||
if (V->getType() == DestTy)
|
if (V->getType() == DestTy)
|
||||||
return V;
|
return V;
|
||||||
if (Constant *VC = dyn_cast<Constant>(V))
|
if (Constant *VC = dyn_cast<Constant>(V))
|
||||||
return ConstantExpr::getIntegerCast(VC, DestTy, isSigned);
|
return Folder.CreateIntCast(VC, DestTy, isSigned);
|
||||||
return Insert(CastInst::CreateIntegerCast(V, DestTy, isSigned), Name);
|
return Insert(CastInst::CreateIntegerCast(V, DestTy, isSigned), Name);
|
||||||
}
|
}
|
||||||
|
|
||||||
//===--------------------------------------------------------------------===//
|
//===--------------------------------------------------------------------===//
|
||||||
// Instruction creation methods: Compare Instructions
|
// Instruction creation methods: Compare Instructions
|
||||||
//===--------------------------------------------------------------------===//
|
//===--------------------------------------------------------------------===//
|
||||||
|
|
||||||
Value *CreateICmpEQ(Value *LHS, Value *RHS, const char *Name = "") {
|
Value *CreateICmpEQ(Value *LHS, Value *RHS, const char *Name = "") {
|
||||||
return CreateICmp(ICmpInst::ICMP_EQ, LHS, RHS, Name);
|
return CreateICmp(ICmpInst::ICMP_EQ, LHS, RHS, Name);
|
||||||
}
|
}
|
||||||
@ -439,7 +445,7 @@ public:
|
|||||||
Value *CreateICmpSLE(Value *LHS, Value *RHS, const char *Name = "") {
|
Value *CreateICmpSLE(Value *LHS, Value *RHS, const char *Name = "") {
|
||||||
return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name);
|
return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name);
|
||||||
}
|
}
|
||||||
|
|
||||||
Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const char *Name = "") {
|
Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const char *Name = "") {
|
||||||
return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name);
|
return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name);
|
||||||
}
|
}
|
||||||
@ -483,33 +489,33 @@ public:
|
|||||||
return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name);
|
return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name);
|
||||||
}
|
}
|
||||||
|
|
||||||
Value *CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
|
Value *CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
|
||||||
const char *Name = "") {
|
const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::getCompare(P, LC, RC);
|
return Folder.CreateCompare(P, LC, RC);
|
||||||
return Insert(new ICmpInst(P, LHS, RHS), Name);
|
return Insert(new ICmpInst(P, LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
Value *CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
|
Value *CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
|
||||||
const char *Name = "") {
|
const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::getCompare(P, LC, RC);
|
return Folder.CreateCompare(P, LC, RC);
|
||||||
return Insert(new FCmpInst(P, LHS, RHS), Name);
|
return Insert(new FCmpInst(P, LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
|
|
||||||
Value *CreateVICmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
|
Value *CreateVICmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
|
||||||
const char *Name = "") {
|
const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::getCompare(P, LC, RC);
|
return Folder.CreateCompare(P, LC, RC);
|
||||||
return Insert(new VICmpInst(P, LHS, RHS), Name);
|
return Insert(new VICmpInst(P, LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
Value *CreateVFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
|
Value *CreateVFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
|
||||||
const char *Name = "") {
|
const char *Name = "") {
|
||||||
if (Constant *LC = dyn_cast<Constant>(LHS))
|
if (Constant *LC = dyn_cast<Constant>(LHS))
|
||||||
if (Constant *RC = dyn_cast<Constant>(RHS))
|
if (Constant *RC = dyn_cast<Constant>(RHS))
|
||||||
return ConstantExpr::getCompare(P, LC, RC);
|
return Folder.CreateCompare(P, LC, RC);
|
||||||
return Insert(new VFCmpInst(P, LHS, RHS), Name);
|
return Insert(new VFCmpInst(P, LHS, RHS), Name);
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -542,9 +548,9 @@ public:
|
|||||||
Value *Args[] = { Arg1, Arg2, Arg3, Arg4 };
|
Value *Args[] = { Arg1, Arg2, Arg3, Arg4 };
|
||||||
return Insert(CallInst::Create(Callee, Args, Args+4), Name);
|
return Insert(CallInst::Create(Callee, Args, Args+4), Name);
|
||||||
}
|
}
|
||||||
|
|
||||||
template<typename InputIterator>
|
template<typename InputIterator>
|
||||||
CallInst *CreateCall(Value *Callee, InputIterator ArgBegin,
|
CallInst *CreateCall(Value *Callee, InputIterator ArgBegin,
|
||||||
InputIterator ArgEnd, const char *Name = "") {
|
InputIterator ArgEnd, const char *Name = "") {
|
||||||
return Insert(CallInst::Create(Callee, ArgBegin, ArgEnd), Name);
|
return Insert(CallInst::Create(Callee, ArgBegin, ArgEnd), Name);
|
||||||
}
|
}
|
||||||
@ -554,7 +560,7 @@ public:
|
|||||||
if (Constant *CC = dyn_cast<Constant>(C))
|
if (Constant *CC = dyn_cast<Constant>(C))
|
||||||
if (Constant *TC = dyn_cast<Constant>(True))
|
if (Constant *TC = dyn_cast<Constant>(True))
|
||||||
if (Constant *FC = dyn_cast<Constant>(False))
|
if (Constant *FC = dyn_cast<Constant>(False))
|
||||||
return ConstantExpr::getSelect(CC, TC, FC);
|
return Folder.CreateSelect(CC, TC, FC);
|
||||||
return Insert(SelectInst::Create(C, True, False), Name);
|
return Insert(SelectInst::Create(C, True, False), Name);
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -566,7 +572,7 @@ public:
|
|||||||
const char *Name = "") {
|
const char *Name = "") {
|
||||||
if (Constant *VC = dyn_cast<Constant>(Vec))
|
if (Constant *VC = dyn_cast<Constant>(Vec))
|
||||||
if (Constant *IC = dyn_cast<Constant>(Idx))
|
if (Constant *IC = dyn_cast<Constant>(Idx))
|
||||||
return ConstantExpr::getExtractElement(VC, IC);
|
return Folder.CreateExtractElement(VC, IC);
|
||||||
return Insert(new ExtractElementInst(Vec, Idx), Name);
|
return Insert(new ExtractElementInst(Vec, Idx), Name);
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -575,7 +581,7 @@ public:
|
|||||||
if (Constant *VC = dyn_cast<Constant>(Vec))
|
if (Constant *VC = dyn_cast<Constant>(Vec))
|
||||||
if (Constant *NC = dyn_cast<Constant>(NewElt))
|
if (Constant *NC = dyn_cast<Constant>(NewElt))
|
||||||
if (Constant *IC = dyn_cast<Constant>(Idx))
|
if (Constant *IC = dyn_cast<Constant>(Idx))
|
||||||
return ConstantExpr::getInsertElement(VC, NC, IC);
|
return Folder.CreateInsertElement(VC, NC, IC);
|
||||||
return Insert(InsertElementInst::Create(Vec, NewElt, Idx), Name);
|
return Insert(InsertElementInst::Create(Vec, NewElt, Idx), Name);
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -584,14 +590,14 @@ public:
|
|||||||
if (Constant *V1C = dyn_cast<Constant>(V1))
|
if (Constant *V1C = dyn_cast<Constant>(V1))
|
||||||
if (Constant *V2C = dyn_cast<Constant>(V2))
|
if (Constant *V2C = dyn_cast<Constant>(V2))
|
||||||
if (Constant *MC = dyn_cast<Constant>(Mask))
|
if (Constant *MC = dyn_cast<Constant>(Mask))
|
||||||
return ConstantExpr::getShuffleVector(V1C, V2C, MC);
|
return Folder.CreateShuffleVector(V1C, V2C, MC);
|
||||||
return Insert(new ShuffleVectorInst(V1, V2, Mask), Name);
|
return Insert(new ShuffleVectorInst(V1, V2, Mask), Name);
|
||||||
}
|
}
|
||||||
|
|
||||||
Value *CreateExtractValue(Value *Agg, unsigned Idx,
|
Value *CreateExtractValue(Value *Agg, unsigned Idx,
|
||||||
const char *Name = "") {
|
const char *Name = "") {
|
||||||
if (Constant *AggC = dyn_cast<Constant>(Agg))
|
if (Constant *AggC = dyn_cast<Constant>(Agg))
|
||||||
return ConstantExpr::getExtractValue(AggC, &Idx, 1);
|
return Folder.CreateExtractValue(AggC, &Idx, 1);
|
||||||
return Insert(ExtractValueInst::Create(Agg, Idx), Name);
|
return Insert(ExtractValueInst::Create(Agg, Idx), Name);
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -601,7 +607,7 @@ public:
|
|||||||
InputIterator IdxEnd,
|
InputIterator IdxEnd,
|
||||||
const char *Name = "") {
|
const char *Name = "") {
|
||||||
if (Constant *AggC = dyn_cast<Constant>(Agg))
|
if (Constant *AggC = dyn_cast<Constant>(Agg))
|
||||||
return ConstantExpr::getExtractValue(AggC, IdxBegin, IdxEnd - IdxBegin);
|
return Folder.CreateExtractValue(AggC, IdxBegin, IdxEnd - IdxBegin);
|
||||||
return Insert(ExtractValueInst::Create(Agg, IdxBegin, IdxEnd), Name);
|
return Insert(ExtractValueInst::Create(Agg, IdxBegin, IdxEnd), Name);
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -609,7 +615,7 @@ public:
|
|||||||
const char *Name = "") {
|
const char *Name = "") {
|
||||||
if (Constant *AggC = dyn_cast<Constant>(Agg))
|
if (Constant *AggC = dyn_cast<Constant>(Agg))
|
||||||
if (Constant *ValC = dyn_cast<Constant>(Val))
|
if (Constant *ValC = dyn_cast<Constant>(Val))
|
||||||
return ConstantExpr::getInsertValue(AggC, ValC, &Idx, 1);
|
return Folder.CreateInsertValue(AggC, ValC, &Idx, 1);
|
||||||
return Insert(InsertValueInst::Create(Agg, Val, Idx), Name);
|
return Insert(InsertValueInst::Create(Agg, Val, Idx), Name);
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -620,12 +626,12 @@ public:
|
|||||||
const char *Name = "") {
|
const char *Name = "") {
|
||||||
if (Constant *AggC = dyn_cast<Constant>(Agg))
|
if (Constant *AggC = dyn_cast<Constant>(Agg))
|
||||||
if (Constant *ValC = dyn_cast<Constant>(Val))
|
if (Constant *ValC = dyn_cast<Constant>(Val))
|
||||||
return ConstantExpr::getInsertValue(AggC, ValC,
|
return Folder.CreateInsertValue(AggC, ValC,
|
||||||
IdxBegin, IdxEnd - IdxBegin);
|
IdxBegin, IdxEnd - IdxBegin);
|
||||||
return Insert(InsertValueInst::Create(Agg, Val, IdxBegin, IdxEnd), Name);
|
return Insert(InsertValueInst::Create(Agg, Val, IdxBegin, IdxEnd), Name);
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
193
include/llvm/Support/TargetFolder.h
Normal file
193
include/llvm/Support/TargetFolder.h
Normal file
@ -0,0 +1,193 @@
|
|||||||
|
//====-- llvm/Support/TargetFolder.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 TargetFolder class, which provides a set of methods
|
||||||
|
// for creating constants, with target dependent folding.
|
||||||
|
//
|
||||||
|
//
|
||||||
|
//===----------------------------------------------------------------------===//
|
||||||
|
|
||||||
|
#ifndef LLVM_SUPPORT_TARGETFOLDER_H
|
||||||
|
#define LLVM_SUPPORT_TARGETFOLDER_H
|
||||||
|
|
||||||
|
#include "llvm/Constants.h"
|
||||||
|
#include "llvm/Analysis/ConstantFolding.h"
|
||||||
|
|
||||||
|
namespace llvm {
|
||||||
|
|
||||||
|
class TargetData;
|
||||||
|
|
||||||
|
/// TargetFolder - Create constants with target dependent folding.
|
||||||
|
class TargetFolder {
|
||||||
|
const TargetData &TD;
|
||||||
|
|
||||||
|
/// Fold - Fold the constant using target specific information.
|
||||||
|
Constant *Fold(Constant *C) const {
|
||||||
|
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
|
||||||
|
if (Constant *CF = ConstantFoldConstantExpression(CE, &TD))
|
||||||
|
return CF;
|
||||||
|
return C;
|
||||||
|
}
|
||||||
|
|
||||||
|
public:
|
||||||
|
TargetFolder(const TargetData &TheTD) : TD(TheTD) {}
|
||||||
|
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
// Binary Operators
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
|
||||||
|
Constant *CreateAdd(Constant *LHS, Constant *RHS) const {
|
||||||
|
return Fold(ConstantExpr::getAdd(LHS, RHS));
|
||||||
|
}
|
||||||
|
Constant *CreateSub(Constant *LHS, Constant *RHS) const {
|
||||||
|
return Fold(ConstantExpr::getSub(LHS, RHS));
|
||||||
|
}
|
||||||
|
Constant *CreateMul(Constant *LHS, Constant *RHS) const {
|
||||||
|
return Fold(ConstantExpr::getMul(LHS, RHS));
|
||||||
|
}
|
||||||
|
Constant *CreateUDiv(Constant *LHS, Constant *RHS) const {
|
||||||
|
return Fold(ConstantExpr::getUDiv(LHS, RHS));
|
||||||
|
}
|
||||||
|
Constant *CreateSDiv(Constant *LHS, Constant *RHS) const {
|
||||||
|
return Fold(ConstantExpr::getSDiv(LHS, RHS));
|
||||||
|
}
|
||||||
|
Constant *CreateFDiv(Constant *LHS, Constant *RHS) const {
|
||||||
|
return Fold(ConstantExpr::getFDiv(LHS, RHS));
|
||||||
|
}
|
||||||
|
Constant *CreateURem(Constant *LHS, Constant *RHS) const {
|
||||||
|
return Fold(ConstantExpr::getURem(LHS, RHS));
|
||||||
|
}
|
||||||
|
Constant *CreateSRem(Constant *LHS, Constant *RHS) const {
|
||||||
|
return Fold(ConstantExpr::getSRem(LHS, RHS));
|
||||||
|
}
|
||||||
|
Constant *CreateFRem(Constant *LHS, Constant *RHS) const {
|
||||||
|
return Fold(ConstantExpr::getFRem(LHS, RHS));
|
||||||
|
}
|
||||||
|
Constant *CreateShl(Constant *LHS, Constant *RHS) const {
|
||||||
|
return Fold(ConstantExpr::getShl(LHS, RHS));
|
||||||
|
}
|
||||||
|
Constant *CreateLShr(Constant *LHS, Constant *RHS) const {
|
||||||
|
return Fold(ConstantExpr::getLShr(LHS, RHS));
|
||||||
|
}
|
||||||
|
Constant *CreateAShr(Constant *LHS, Constant *RHS) const {
|
||||||
|
return Fold(ConstantExpr::getAShr(LHS, RHS));
|
||||||
|
}
|
||||||
|
Constant *CreateAnd(Constant *LHS, Constant *RHS) const {
|
||||||
|
return Fold(ConstantExpr::getAnd(LHS, RHS));
|
||||||
|
}
|
||||||
|
Constant *CreateOr(Constant *LHS, Constant *RHS) const {
|
||||||
|
return Fold(ConstantExpr::getOr(LHS, RHS));
|
||||||
|
}
|
||||||
|
Constant *CreateXor(Constant *LHS, Constant *RHS) const {
|
||||||
|
return Fold(ConstantExpr::getXor(LHS, RHS));
|
||||||
|
}
|
||||||
|
|
||||||
|
Constant *CreateBinOp(Instruction::BinaryOps Opc,
|
||||||
|
Constant *LHS, Constant *RHS) const {
|
||||||
|
return Fold(ConstantExpr::get(Opc, LHS, RHS));
|
||||||
|
}
|
||||||
|
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
// Unary Operators
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
|
||||||
|
Constant *CreateNeg(Constant *C) const {
|
||||||
|
return Fold(ConstantExpr::getNeg(C));
|
||||||
|
}
|
||||||
|
Constant *CreateNot(Constant *C) const {
|
||||||
|
return Fold(ConstantExpr::getNot(C));
|
||||||
|
}
|
||||||
|
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
// Memory Instructions
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
|
||||||
|
Constant *CreateGetElementPtr(Constant *C, Constant* const *IdxList,
|
||||||
|
unsigned NumIdx) const {
|
||||||
|
return Fold(ConstantExpr::getGetElementPtr(C, IdxList, NumIdx));
|
||||||
|
}
|
||||||
|
Constant *CreateGetElementPtr(Constant *C, Value* const *IdxList,
|
||||||
|
unsigned NumIdx) const {
|
||||||
|
return Fold(ConstantExpr::getGetElementPtr(C, IdxList, NumIdx));
|
||||||
|
}
|
||||||
|
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
// Cast/Conversion Operators
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
|
||||||
|
Constant *CreateCast(Instruction::CastOps Op, Constant *C,
|
||||||
|
const Type *DestTy) const {
|
||||||
|
if (C->getType() == DestTy)
|
||||||
|
return C; // avoid calling Fold
|
||||||
|
return Fold(ConstantExpr::getCast(Op, C, DestTy));
|
||||||
|
}
|
||||||
|
Constant *CreateIntCast(Constant *C, const Type *DestTy,
|
||||||
|
bool isSigned) const {
|
||||||
|
if (C->getType() == DestTy)
|
||||||
|
return C; // avoid calling Fold
|
||||||
|
return Fold(ConstantExpr::getIntegerCast(C, DestTy, isSigned));
|
||||||
|
}
|
||||||
|
|
||||||
|
Constant *CreateBitCast(Constant *C, const Type *DestTy) const {
|
||||||
|
return CreateCast(Instruction::BitCast, C, DestTy);
|
||||||
|
}
|
||||||
|
Constant *CreateIntToPtr(Constant *C, const Type *DestTy) const {
|
||||||
|
return CreateCast(Instruction::IntToPtr, C, DestTy);
|
||||||
|
}
|
||||||
|
Constant *CreatePtrToInt(Constant *C, const Type *DestTy) const {
|
||||||
|
return CreateCast(Instruction::PtrToInt, C, DestTy);
|
||||||
|
}
|
||||||
|
Constant *CreateTruncOrBitCast(Constant *C, const Type *DestTy) const {
|
||||||
|
if (C->getType() == DestTy)
|
||||||
|
return C; // avoid calling Fold
|
||||||
|
return Fold(ConstantExpr::getTruncOrBitCast(C, DestTy));
|
||||||
|
}
|
||||||
|
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
// Compare Instructions
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
|
||||||
|
Constant *CreateCompare(CmpInst::Predicate P, Constant *LHS, Constant *RHS) const {
|
||||||
|
return Fold(ConstantExpr::getCompare(P, LHS, RHS));
|
||||||
|
}
|
||||||
|
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
// Other Instructions
|
||||||
|
//===--------------------------------------------------------------------===//
|
||||||
|
|
||||||
|
Constant *CreateSelect(Constant *C, Constant *True, Constant *False) const {
|
||||||
|
return Fold(ConstantExpr::getSelect(C, True, False));
|
||||||
|
}
|
||||||
|
|
||||||
|
Constant *CreateExtractElement(Constant *Vec, Constant *Idx) const {
|
||||||
|
return Fold(ConstantExpr::getExtractElement(Vec, Idx));
|
||||||
|
}
|
||||||
|
|
||||||
|
Constant *CreateInsertElement(Constant *Vec, Constant *NewElt, Constant *Idx)const {
|
||||||
|
return Fold(ConstantExpr::getInsertElement(Vec, NewElt, Idx));
|
||||||
|
}
|
||||||
|
|
||||||
|
Constant *CreateShuffleVector(Constant *V1, Constant *V2, Constant *Mask) const {
|
||||||
|
return Fold(ConstantExpr::getShuffleVector(V1, V2, Mask));
|
||||||
|
}
|
||||||
|
|
||||||
|
Constant *CreateExtractValue(Constant *Agg, const unsigned *IdxList,
|
||||||
|
unsigned NumIdx) const {
|
||||||
|
return Fold(ConstantExpr::getExtractValue(Agg, IdxList, NumIdx));
|
||||||
|
}
|
||||||
|
|
||||||
|
Constant *CreateInsertValue(Constant *Agg, Constant *Val,
|
||||||
|
const unsigned *IdxList, unsigned NumIdx) const {
|
||||||
|
return Fold(ConstantExpr::getInsertValue(Agg, Val, IdxList, NumIdx));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
Loading…
Reference in New Issue
Block a user