Add convenience functions for creating exact sdiv operators, and

use them in CreatePtrDiff.

llvm-svn: 78682
This commit is contained in:
Dan Gohman 2009-08-11 17:05:24 +00:00
parent 1d382f0ee7
commit 82b3823bb7
7 changed files with 51 additions and 4 deletions

View File

@ -636,6 +636,8 @@ public:
static Constant *getIntToPtr(Constant *C, const Type *Ty);
static Constant *getBitCast (Constant *C, const Type *Ty);
static Constant* getExactSDiv(Constant* C1, Constant* C2);
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);

View File

@ -18,6 +18,7 @@
#include "llvm/Instruction.h"
#include "llvm/OperandTraits.h"
#include "llvm/Operator.h"
#include "llvm/DerivedTypes.h"
namespace llvm {
@ -195,6 +196,27 @@ public:
#include "llvm/Instruction.def"
/// CreateExactSDiv - Create an SDiv operator with the exact flag set.
///
static BinaryOperator *CreateExactSDiv(Value *V1, Value *V2,
const Twine &Name = "") {
BinaryOperator *BO = CreateSDiv(V1, V2, Name);
cast<SDivOperator>(BO)->setIsExact(true);
return BO;
}
static BinaryOperator *CreateExactSDiv(Value *V1, Value *V2,
const Twine &Name, BasicBlock *BB) {
BinaryOperator *BO = CreateSDiv(V1, V2, Name, BB);
cast<SDivOperator>(BO)->setIsExact(true);
return BO;
}
static BinaryOperator *CreateExactSDiv(Value *V1, Value *V2,
const Twine &Name, Instruction *I) {
BinaryOperator *BO = CreateSDiv(V1, V2, Name, I);
cast<SDivOperator>(BO)->setIsExact(true);
return BO;
}
/// Helper functions to construct and inspect unary operations (NEG and NOT)
/// via binary operators SUB and XOR:
///

View File

@ -56,6 +56,9 @@ public:
Constant *CreateSDiv(Constant *LHS, Constant *RHS) const {
return ConstantExpr::getSDiv(LHS, RHS);
}
Constant *CreateExactSDiv(Constant *LHS, Constant *RHS) const {
return ConstantExpr::getExactSDiv(LHS, RHS);
}
Constant *CreateFDiv(Constant *LHS, Constant *RHS) const {
return ConstantExpr::getFDiv(LHS, RHS);
}

View File

@ -241,6 +241,12 @@ public:
return Folder.CreateSDiv(LC, RC);
return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name);
}
Value *CreateExactSDiv(Value *LHS, Value *RHS, const char *Name = "") {
if (Constant *LC = dyn_cast<Constant>(LHS))
if (Constant *RC = dyn_cast<Constant>(RHS))
return Folder.CreateExactSDiv(LC, RC);
return Insert(BinaryOperator::CreateExactSDiv(LHS, RHS), Name);
}
Value *CreateFDiv(Value *LHS, Value *RHS, const char *Name = "") {
if (Constant *LC = dyn_cast<Constant>(LHS))
if (Constant *RC = dyn_cast<Constant>(RHS))
@ -719,7 +725,9 @@ public:
/// CreatePtrDiff - Return the i64 difference between two pointer values,
/// dividing out the size of the pointed-to objects. This is intended to
/// implement C-style pointer subtraction.
/// implement C-style pointer subtraction. As such, the pointers must be
/// appropriately aligned for their element types and pointing into the
/// same object.
Value *CreatePtrDiff(Value *LHS, Value *RHS, const char *Name = "") {
assert(LHS->getType() == RHS->getType() &&
"Pointer subtraction operand types must match!");
@ -727,9 +735,9 @@ public:
Value *LHS_int = CreatePtrToInt(LHS, Type::Int64Ty);
Value *RHS_int = CreatePtrToInt(RHS, Type::Int64Ty);
Value *Difference = CreateSub(LHS_int, RHS_int);
return CreateSDiv(Difference,
ConstantExpr::getSizeOf(ArgType->getElementType()),
Name);
return CreateExactSDiv(Difference,
ConstantExpr::getSizeOf(ArgType->getElementType()),
Name);
}
};

View File

@ -63,6 +63,9 @@ public:
Value *CreateSDiv(Constant *LHS, Constant *RHS) const {
return BinaryOperator::CreateSDiv(LHS, RHS);
}
Value *CreateExactSDiv(Constant *LHS, Constant *RHS) const {
return BinaryOperator::CreateExactSDiv(LHS, RHS);
}
Value *CreateFDiv(Constant *LHS, Constant *RHS) const {
return BinaryOperator::CreateFDiv(LHS, RHS);
}

View File

@ -72,6 +72,9 @@ public:
Constant *CreateSDiv(Constant *LHS, Constant *RHS) const {
return Fold(ConstantExpr::getSDiv(LHS, RHS));
}
Constant *CreateExactSDiv(Constant *LHS, Constant *RHS) const {
return Fold(ConstantExpr::getExactSDiv(LHS, RHS));
}
Constant *CreateFDiv(Constant *LHS, Constant *RHS) const {
return Fold(ConstantExpr::getFDiv(LHS, RHS));
}

View File

@ -605,6 +605,12 @@ Constant* ConstantVector::get(Constant* const* Vals, unsigned NumVals) {
return get(std::vector<Constant*>(Vals, Vals+NumVals));
}
Constant* ConstantExpr::getExactSDiv(Constant* C1, Constant* C2) {
Constant *C = getSDiv(C1, C2);
cast<SDivOperator>(C)->setIsExact(true);
return C;
}
// Utility function for determining if a ConstantExpr is a CastOp or not. This
// can't be inline because we don't want to #include Instruction.h into
// Constant.h