[llvm-commits] [llvm] r75445 - in /llvm/trunk: docs/tutorial/ examples/BrainF/ examples/Kaleidoscope/ include/llvm/ include/llvm/CodeGen/ include/llvm/Support/ lib/Analysis/ lib/Analysis/IPA/ lib/CodeGen/ lib/CodeGen/SelectionDAG/ lib/Target/ lib/Target/CBackend/ lib/Target/Mips/ lib/Target/Mips/AsmPrinter/ lib/Target/X86/ lib/Transforms/Scalar/ lib/Transforms/Utils/ lib/VMCore/ tools/bugpoint/ tools/lto/ unittests/ExecutionEngine/JIT/ unittests/Support/
Owen Anderson
resistor at mac.com
Sun Jul 12 21:09:19 PDT 2009
Author: resistor
Date: Sun Jul 12 23:09:18 2009
New Revision: 75445
URL: http://llvm.org/viewvc/llvm-project?rev=75445&view=rev
Log:
Begin the painful process of tearing apart the rat'ss nest that is Constants.cpp and ConstantFold.cpp.
This involves temporarily hard wiring some parts to use the global context. This isn't ideal, but it's
the only way I could figure out to make this process vaguely incremental.
Modified:
llvm/trunk/docs/tutorial/LangImpl5.html
llvm/trunk/docs/tutorial/LangImpl6.html
llvm/trunk/docs/tutorial/LangImpl7.html
llvm/trunk/examples/BrainF/BrainF.cpp
llvm/trunk/examples/Kaleidoscope/toy.cpp
llvm/trunk/include/llvm/CodeGen/FastISel.h
llvm/trunk/include/llvm/Constant.h
llvm/trunk/include/llvm/Constants.h
llvm/trunk/include/llvm/InstrTypes.h
llvm/trunk/include/llvm/LLVMContext.h
llvm/trunk/include/llvm/Support/IRBuilder.h
llvm/trunk/lib/Analysis/DebugInfo.cpp
llvm/trunk/lib/Analysis/IPA/Andersens.cpp
llvm/trunk/lib/Analysis/ScalarEvolution.cpp
llvm/trunk/lib/CodeGen/IntrinsicLowering.cpp
llvm/trunk/lib/CodeGen/MachOWriter.cpp
llvm/trunk/lib/CodeGen/SelectionDAG/FastISel.cpp
llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp
llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuild.h
llvm/trunk/lib/CodeGen/ShadowStackGC.cpp
llvm/trunk/lib/CodeGen/UnreachableBlockElim.cpp
llvm/trunk/lib/Target/CBackend/CBackend.cpp
llvm/trunk/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp
llvm/trunk/lib/Target/Mips/MipsISelLowering.cpp
llvm/trunk/lib/Target/TargetAsmInfo.cpp
llvm/trunk/lib/Target/X86/X86FastISel.cpp
llvm/trunk/lib/Target/X86/X86InstrInfo.cpp
llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp
llvm/trunk/lib/Transforms/Scalar/PredicateSimplifier.cpp
llvm/trunk/lib/Transforms/Scalar/Reassociate.cpp
llvm/trunk/lib/Transforms/Utils/LowerInvoke.cpp
llvm/trunk/lib/VMCore/ConstantFold.cpp
llvm/trunk/lib/VMCore/ConstantFold.h
llvm/trunk/lib/VMCore/Constants.cpp
llvm/trunk/lib/VMCore/Instructions.cpp
llvm/trunk/lib/VMCore/LLVMContext.cpp
llvm/trunk/tools/bugpoint/CrashDebugger.cpp
llvm/trunk/tools/bugpoint/ExtractFunction.cpp
llvm/trunk/tools/bugpoint/Miscompilation.cpp
llvm/trunk/tools/bugpoint/TestPasses.cpp
llvm/trunk/tools/lto/LTOModule.cpp
llvm/trunk/unittests/ExecutionEngine/JIT/JITTest.cpp
llvm/trunk/unittests/Support/ValueHandleTest.cpp
Modified: llvm/trunk/docs/tutorial/LangImpl5.html
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/docs/tutorial/LangImpl5.html?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/docs/tutorial/LangImpl5.html (original)
+++ llvm/trunk/docs/tutorial/LangImpl5.html Sun Jul 12 23:09:18 2009
@@ -856,7 +856,7 @@
NamedValues.erase(VarName);
// for expr always returns 0.0.
- return Constant::getNullValue(Type::DoubleTy);
+ return TheFunction->getContext()->getNullValue(Type::DoubleTy);
}
</pre>
</div>
Modified: llvm/trunk/docs/tutorial/LangImpl6.html
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/docs/tutorial/LangImpl6.html?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/docs/tutorial/LangImpl6.html (original)
+++ llvm/trunk/docs/tutorial/LangImpl6.html Sun Jul 12 23:09:18 2009
@@ -1570,7 +1570,7 @@
// for expr always returns 0.0.
- return Constant::getNullValue(Type::DoubleTy);
+ return TheFunction->getContext()->getNullValue(Type::DoubleTy);
}
Function *PrototypeAST::Codegen() {
Modified: llvm/trunk/docs/tutorial/LangImpl7.html
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/docs/tutorial/LangImpl7.html?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/docs/tutorial/LangImpl7.html (original)
+++ llvm/trunk/docs/tutorial/LangImpl7.html Sun Jul 12 23:09:18 2009
@@ -1858,7 +1858,7 @@
// for expr always returns 0.0.
- return Constant::getNullValue(Type::DoubleTy);
+ return TheFunction->getContext()->getNullValue(Type::DoubleTy);
}
Value *VarExprAST::Codegen() {
Modified: llvm/trunk/examples/BrainF/BrainF.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/examples/BrainF/BrainF.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/examples/BrainF/BrainF.cpp (original)
+++ llvm/trunk/examples/BrainF/BrainF.cpp Sun Jul 12 23:09:18 2009
@@ -145,7 +145,7 @@
//call i32 @puts(i8 *getelementptr([%d x i8] *@aberrormsg, i32 0, i32 0))
{
- Constant *zero_32 = Constant::getNullValue(IntegerType::Int32Ty);
+ Constant *zero_32 = C.getNullValue(IntegerType::Int32Ty);
Constant *gep_params[] = {
zero_32,
Modified: llvm/trunk/examples/Kaleidoscope/toy.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/examples/Kaleidoscope/toy.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/examples/Kaleidoscope/toy.cpp (original)
+++ llvm/trunk/examples/Kaleidoscope/toy.cpp Sun Jul 12 23:09:18 2009
@@ -854,7 +854,7 @@
// for expr always returns 0.0.
- return Constant::getNullValue(Type::DoubleTy);
+ return TheFunction->getContext()->getNullValue(Type::DoubleTy);
}
Value *VarExprAST::Codegen() {
Modified: llvm/trunk/include/llvm/CodeGen/FastISel.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/FastISel.h?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/include/llvm/CodeGen/FastISel.h (original)
+++ llvm/trunk/include/llvm/CodeGen/FastISel.h Sun Jul 12 23:09:18 2009
@@ -60,6 +60,7 @@
const TargetData &TD;
const TargetInstrInfo &TII;
const TargetLowering &TLI;
+ LLVMContext *Context;
public:
/// startNewBlock - Set the current block to which generated machine
Modified: llvm/trunk/include/llvm/Constant.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Constant.h?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Constant.h (original)
+++ llvm/trunk/include/llvm/Constant.h Sun Jul 12 23:09:18 2009
@@ -18,6 +18,7 @@
namespace llvm {
template<typename T> class SmallVectorImpl;
+ class LLVMContext;
/// If object contains references to other objects, then relocations are
/// usually required for emission of such object (especially in PIC mode). One
@@ -59,10 +60,6 @@
void destroyConstantImpl();
public:
- /// Static constructor to get a '0' constant of arbitrary type...
- ///
- static Constant *getNullValue(const Type *Ty);
-
/// Static constructor to get a '-1' constant. This supports integers and
/// vectors.
///
@@ -98,7 +95,8 @@
/// type, returns the elements of the vector in the specified smallvector.
/// This handles breaking down a vector undef into undef elements, etc. For
/// constant exprs and other cases we can't handle, we return an empty vector.
- void getVectorElements(SmallVectorImpl<Constant*> &Elts) const;
+ void getVectorElements(LLVMContext &Context,
+ SmallVectorImpl<Constant*> &Elts) const;
/// destroyConstant - Called if some element of this constant is no longer
/// valid. At this point only other constants may be on the use_list for this
Modified: llvm/trunk/include/llvm/Constants.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Constants.h?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Constants.h (original)
+++ llvm/trunk/include/llvm/Constants.h Sun Jul 12 23:09:18 2009
@@ -276,9 +276,6 @@
/// considers -0.0 to be null as well as 0.0. :(
virtual bool isNullValue() const;
- // Get a negative zero.
- static ConstantFP *getNegativeZero(const Type* Ty);
-
/// isExactlyValue - We don't rely on operator== working on double values, as
/// it returns true for things that are clearly not equal, like -0.0 and 0.0.
/// As such, this method can be used to do an exact bit-for-bit comparison of
@@ -383,7 +380,7 @@
/// isString) and it ends in a null byte \0 and does not contains any other
/// @endverbatim
/// null bytes except its terminator.
- bool isCString() const;
+ bool isCString(LLVMContext &Context) const;
/// getAsString - If this array is isString(), then this method converts the
/// array to an std::string and returns it. Otherwise, it asserts out.
@@ -694,17 +691,6 @@
return getSelectTy(V1->getType(), C, V1, V2);
}
- /// getAlignOf constant expr - computes the alignment of a type in a target
- /// independent way (Note: the return type is an i32; Note: assumes that i8
- /// is byte aligned).
- ///
- static Constant *getAlignOf(const Type *Ty);
-
- /// getSizeOf constant expr - computes the size of a type in a target
- /// independent way (Note: the return type is an i64).
- ///
- static Constant *getSizeOf(const Type *Ty);
-
/// ConstantExpr::get - Return a binary or shift operator constant expression,
/// folding if possible.
///
@@ -716,8 +702,6 @@
/// ConstantExpr::get* - Return some common constants without having to
/// specify the full Instruction::OPCODE identifier.
///
- static Constant *getNeg(Constant *C);
- static Constant *getFNeg(Constant *C);
static Constant *getNot(Constant *C);
static Constant *getAdd(Constant *C1, Constant *C2);
static Constant *getFAdd(Constant *C1, Constant *C2);
@@ -756,11 +740,6 @@
static Constant *getInsertValue(Constant *Agg, Constant *Val,
const unsigned *IdxList, unsigned NumIdx);
- /// Floating point negation must be implemented with f(x) = -0.0 - x. This
- /// method returns the negative zero constant for floating point or vector
- /// floating point types; for all other types, it returns the null value.
- static Constant *getZeroValueForNegationExpr(const Type *Ty);
-
/// isNullValue - Return true if this is the value that would be returned by
/// getNullValue.
virtual bool isNullValue() const { return false; }
Modified: llvm/trunk/include/llvm/InstrTypes.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/InstrTypes.h?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/include/llvm/InstrTypes.h (original)
+++ llvm/trunk/include/llvm/InstrTypes.h Sun Jul 12 23:09:18 2009
@@ -202,13 +202,17 @@
/// CreateNeg, CreateNot - Create the NEG and NOT
/// instructions out of SUB and XOR instructions.
///
- static BinaryOperator *CreateNeg(Value *Op, const std::string &Name = "",
+ static BinaryOperator *CreateNeg(LLVMContext &Context,
+ Value *Op, const std::string &Name = "",
Instruction *InsertBefore = 0);
- static BinaryOperator *CreateNeg(Value *Op, const std::string &Name,
+ static BinaryOperator *CreateNeg(LLVMContext &Context,
+ Value *Op, const std::string &Name,
BasicBlock *InsertAtEnd);
- static BinaryOperator *CreateFNeg(Value *Op, const std::string &Name = "",
+ static BinaryOperator *CreateFNeg(LLVMContext &Context,
+ Value *Op, const std::string &Name = "",
Instruction *InsertBefore = 0);
- static BinaryOperator *CreateFNeg(Value *Op, const std::string &Name,
+ static BinaryOperator *CreateFNeg(LLVMContext &Context,
+ Value *Op, const std::string &Name,
BasicBlock *InsertAtEnd);
static BinaryOperator *CreateNot(Value *Op, const std::string &Name = "",
Instruction *InsertBefore = 0);
@@ -218,8 +222,8 @@
/// isNeg, isFNeg, isNot - Check if the given Value is a
/// NEG, FNeg, or NOT instruction.
///
- static bool isNeg(const Value *V);
- static bool isFNeg(const Value *V);
+ static bool isNeg(LLVMContext &Context, const Value *V);
+ static bool isFNeg(LLVMContext &Context, const Value *V);
static bool isNot(const Value *V);
/// getNegArgument, getNotArgument - Helper functions to extract the
Modified: llvm/trunk/include/llvm/LLVMContext.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/LLVMContext.h?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/include/llvm/LLVMContext.h (original)
+++ llvm/trunk/include/llvm/LLVMContext.h Sun Jul 12 23:09:18 2009
@@ -120,6 +120,11 @@
bool isSigned);
Constant* getConstantExprFPCast(Constant* C, const Type* Ty);
Constant* getConstantExprSelect(Constant* C, Constant* V1, Constant* V2);
+
+ /// getAlignOf constant expr - computes the alignment of a type in a target
+ /// independent way (Note: the return type is an i32; Note: assumes that i8
+ /// is byte aligned).
+ ///
Constant* getConstantExprAlignOf(const Type* Ty);
Constant* getConstantExprCompare(unsigned short pred,
Constant* C1, Constant* C2);
@@ -162,7 +167,15 @@
Constant* getConstantExprInsertValue(Constant* Agg, Constant* Val,
const unsigned* IdxList,
unsigned NumIdx);
+
+ /// getSizeOf constant expr - computes the size of a type in a target
+ /// independent way (Note: the return type is an i64).
+ ///
Constant* getConstantExprSizeOf(const Type* Ty);
+
+ /// Floating point negation must be implemented with f(x) = -0.0 - x. This
+ /// method returns the negative zero constant for floating point or vector
+ /// floating point types; for all other types, it returns the null value.
Constant* getZeroValueForNegation(const Type* Ty);
// ConstantFP accessors
@@ -200,6 +213,7 @@
StructType* getStructType(bool isPacked=false);
StructType* getStructType(const std::vector<const Type*>& Params,
bool isPacked = false);
+ StructType* getStructType(const Type* type, ...);
// ArrayType accessors
ArrayType* getArrayType(const Type* ElementType, uint64_t NumElements);
Modified: llvm/trunk/include/llvm/Support/IRBuilder.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/IRBuilder.h?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Support/IRBuilder.h (original)
+++ llvm/trunk/include/llvm/Support/IRBuilder.h Sun Jul 12 23:09:18 2009
@@ -311,12 +311,12 @@
Value *CreateNeg(Value *V, const char *Name = "") {
if (Constant *VC = dyn_cast<Constant>(V))
return Folder.CreateNeg(VC);
- return Insert(BinaryOperator::CreateNeg(V), Name);
+ return Insert(BinaryOperator::CreateNeg(getGlobalContext(), V), Name);
}
Value *CreateFNeg(Value *V, const char *Name = "") {
if (Constant *VC = dyn_cast<Constant>(V))
return Folder.CreateFNeg(VC);
- return Insert(BinaryOperator::CreateFNeg(V), Name);
+ return Insert(BinaryOperator::CreateFNeg(getGlobalContext(), V), Name);
}
Value *CreateNot(Value *V, const char *Name = "") {
if (Constant *VC = dyn_cast<Constant>(V))
Modified: llvm/trunk/lib/Analysis/DebugInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/DebugInfo.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/Analysis/DebugInfo.cpp (original)
+++ llvm/trunk/lib/Analysis/DebugInfo.cpp Sun Jul 12 23:09:18 2009
@@ -463,7 +463,7 @@
/// getCastToEmpty - Return this descriptor as a Constant* with type '{}*'.
/// This is only valid when the descriptor is non-null.
Constant *DIFactory::getCastToEmpty(DIDescriptor D) {
- if (D.isNull()) return Constant::getNullValue(EmptyStructPtr);
+ if (D.isNull()) return VMContext.getNullValue(EmptyStructPtr);
return VMContext.getConstantExprBitCast(D.getGV(), EmptyStructPtr);
}
Modified: llvm/trunk/lib/Analysis/IPA/Andersens.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/IPA/Andersens.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/Analysis/IPA/Andersens.cpp (original)
+++ llvm/trunk/lib/Analysis/IPA/Andersens.cpp Sun Jul 12 23:09:18 2009
@@ -693,7 +693,7 @@
// If the object in the points-to set is the null object, then the null
// pointer is a must alias.
if (Pointee == &GraphNodes[NullObject])
- RetVals.push_back(Constant::getNullValue(P->getType()));
+ RetVals.push_back(Context->getNullValue(P->getType()));
}
}
AliasAnalysis::getMustAliases(P, RetVals);
Modified: llvm/trunk/lib/Analysis/ScalarEvolution.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ScalarEvolution.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/Analysis/ScalarEvolution.cpp (original)
+++ llvm/trunk/lib/Analysis/ScalarEvolution.cpp Sun Jul 12 23:09:18 2009
@@ -2084,7 +2084,8 @@
///
const SCEV *ScalarEvolution::getNegativeSCEV(const SCEV *V) {
if (const SCEVConstant *VC = dyn_cast<SCEVConstant>(V))
- return getConstant(cast<ConstantInt>(ConstantExpr::getNeg(VC->getValue())));
+ return getConstant(
+ cast<ConstantInt>(Context->getConstantExprNeg(VC->getValue())));
const Type *Ty = V->getType();
Ty = getEffectiveSCEVType(Ty);
@@ -3284,7 +3285,7 @@
/// the addressed element of the initializer or null if the index expression is
/// invalid.
static Constant *
-GetAddressedElementFromGlobal(GlobalVariable *GV,
+GetAddressedElementFromGlobal(LLVMContext *Context, GlobalVariable *GV,
const std::vector<ConstantInt*> &Indices) {
Constant *Init = GV->getInitializer();
for (unsigned i = 0, e = Indices.size(); i != e; ++i) {
@@ -3298,10 +3299,10 @@
} else if (isa<ConstantAggregateZero>(Init)) {
if (const StructType *STy = dyn_cast<StructType>(Init->getType())) {
assert(Idx < STy->getNumElements() && "Bad struct index!");
- Init = Constant::getNullValue(STy->getElementType(Idx));
+ Init = Context->getNullValue(STy->getElementType(Idx));
} else if (const ArrayType *ATy = dyn_cast<ArrayType>(Init->getType())) {
if (Idx >= ATy->getNumElements()) return 0; // Bogus program
- Init = Constant::getNullValue(ATy->getElementType());
+ Init = Context->getNullValue(ATy->getElementType());
} else {
LLVM_UNREACHABLE("Unknown constant aggregate type!");
}
@@ -3372,7 +3373,7 @@
// Form the GEP offset.
Indexes[VarIdxNum] = Val;
- Constant *Result = GetAddressedElementFromGlobal(GV, Indexes);
+ Constant *Result = GetAddressedElementFromGlobal(Context, GV, Indexes);
if (Result == 0) break; // Cannot compute!
// Evaluate the condition for this iteration.
Modified: llvm/trunk/lib/CodeGen/IntrinsicLowering.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/IntrinsicLowering.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/IntrinsicLowering.cpp (original)
+++ llvm/trunk/lib/CodeGen/IntrinsicLowering.cpp Sun Jul 12 23:09:18 2009
@@ -315,6 +315,7 @@
void IntrinsicLowering::LowerIntrinsicCall(CallInst *CI) {
IRBuilder<> Builder(CI->getParent(), CI);
+ LLVMContext *Context = CI->getParent()->getContext();
Function *Callee = CI->getCalledFunction();
assert(Callee && "Cannot lower an indirect call!");
@@ -340,7 +341,7 @@
}
case Intrinsic::sigsetjmp:
if (CI->getType() != Type::VoidTy)
- CI->replaceAllUsesWith(Constant::getNullValue(CI->getType()));
+ CI->replaceAllUsesWith(Context->getNullValue(CI->getType()));
break;
case Intrinsic::longjmp: {
@@ -387,7 +388,7 @@
"save" : "restore") << " intrinsic.\n";
Warned = true;
if (Callee->getIntrinsicID() == Intrinsic::stacksave)
- CI->replaceAllUsesWith(Constant::getNullValue(CI->getType()));
+ CI->replaceAllUsesWith(Context->getNullValue(CI->getType()));
break;
}
@@ -422,7 +423,7 @@
case Intrinsic::eh_exception:
case Intrinsic::eh_selector_i32:
case Intrinsic::eh_selector_i64:
- CI->replaceAllUsesWith(Constant::getNullValue(CI->getType()));
+ CI->replaceAllUsesWith(Context->getNullValue(CI->getType()));
break;
case Intrinsic::eh_typeid_for_i32:
Modified: llvm/trunk/lib/CodeGen/MachOWriter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/MachOWriter.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/MachOWriter.cpp (original)
+++ llvm/trunk/lib/CodeGen/MachOWriter.cpp Sun Jul 12 23:09:18 2009
@@ -123,7 +123,7 @@
// getConstSection - Get constant section for Constant 'C'
MachOSection *MachOWriter::getConstSection(Constant *C) {
const ConstantArray *CVA = dyn_cast<ConstantArray>(C);
- if (CVA && CVA->isCString())
+ if (CVA && CVA->isCString(*Context))
return getSection("__TEXT", "__cstring",
MachOSection::S_CSTRING_LITERALS);
Modified: llvm/trunk/lib/CodeGen/SelectionDAG/FastISel.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/FastISel.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/SelectionDAG/FastISel.cpp (original)
+++ llvm/trunk/lib/CodeGen/SelectionDAG/FastISel.cpp Sun Jul 12 23:09:18 2009
@@ -92,7 +92,7 @@
} else if (isa<ConstantPointerNull>(V)) {
// Translate this as an integer zero so that it can be
// local-CSE'd with actual integer zeros.
- Reg = getRegForValue(Constant::getNullValue(TD.getIntPtrType()));
+ Reg = getRegForValue(Context->getNullValue(TD.getIntPtrType()));
} else if (ConstantFP *CF = dyn_cast<ConstantFP>(V)) {
Reg = FastEmit_f(VT, VT, ISD::ConstantFP, CF);
@@ -480,7 +480,7 @@
UpdateValueMap(I, ResultReg);
} else {
unsigned ResultReg =
- getRegForValue(Constant::getNullValue(I->getType()));
+ getRegForValue(Context->getNullValue(I->getType()));
UpdateValueMap(I, ResultReg);
}
return true;
@@ -753,7 +753,8 @@
TM(MF.getTarget()),
TD(*TM.getTargetData()),
TII(*TM.getInstrInfo()),
- TLI(*TM.getTargetLowering()) {
+ TLI(*TM.getTargetLowering()),
+ Context(mf.getFunction()->getContext()) {
}
FastISel::~FastISel() {}
Modified: llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp (original)
+++ llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp Sun Jul 12 23:09:18 2009
@@ -2139,7 +2139,7 @@
const VectorType *DestTy = cast<VectorType>(I.getType());
const Type *ElTy = DestTy->getElementType();
unsigned VL = DestTy->getNumElements();
- std::vector<Constant*> NZ(VL, ConstantFP::getNegativeZero(ElTy));
+ std::vector<Constant*> NZ(VL, Context->getConstantFPNegativeZero(ElTy));
Constant *CNZ = ConstantVector::get(&NZ[0], NZ.size());
if (CV == CNZ) {
SDValue Op2 = getValue(I.getOperand(1));
@@ -2150,7 +2150,8 @@
}
}
if (ConstantFP *CFP = dyn_cast<ConstantFP>(I.getOperand(0)))
- if (CFP->isExactlyValue(ConstantFP::getNegativeZero(Ty)->getValueAPF())) {
+ if (CFP->isExactlyValue(
+ Context->getConstantFPNegativeZero(Ty)->getValueAPF())) {
SDValue Op2 = getValue(I.getOperand(1));
setValue(&I, DAG.getNode(ISD::FNEG, getCurDebugLoc(),
Op2.getValueType(), Op2));
@@ -2398,7 +2399,7 @@
// Convert the ConstantVector mask operand into an array of ints, with -1
// representing undef values.
SmallVector<Constant*, 8> MaskElts;
- cast<Constant>(I.getOperand(2))->getVectorElements(MaskElts);
+ cast<Constant>(I.getOperand(2))->getVectorElements(*Context, MaskElts);
unsigned MaskNumElts = MaskElts.size();
for (unsigned i = 0; i != MaskNumElts; ++i) {
if (isa<UndefValue>(MaskElts[i]))
Modified: llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuild.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuild.h?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuild.h (original)
+++ llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuild.h Sun Jul 12 23:09:18 2009
@@ -15,6 +15,7 @@
#define SELECTIONDAGBUILD_H
#include "llvm/Constants.h"
+#include "llvm/CodeGen/SelectionDAG.h"
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/DenseMap.h"
#ifndef NDEBUG
@@ -362,11 +363,14 @@
/// GFI - Garbage collection metadata for the function.
GCFunctionInfo *GFI;
+ LLVMContext *Context;
+
SelectionDAGLowering(SelectionDAG &dag, TargetLowering &tli,
FunctionLoweringInfo &funcinfo,
CodeGenOpt::Level ol)
: CurDebugLoc(DebugLoc::getUnknownLoc()),
- TLI(tli), DAG(dag), FuncInfo(funcinfo), OptLevel(ol) {
+ TLI(tli), DAG(dag), FuncInfo(funcinfo), OptLevel(ol),
+ Context(dag.getContext()) {
}
void init(GCFunctionInfo *gfi, AliasAnalysis &aa);
Modified: llvm/trunk/lib/CodeGen/ShadowStackGC.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/ShadowStackGC.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/ShadowStackGC.cpp (original)
+++ llvm/trunk/lib/CodeGen/ShadowStackGC.cpp Sun Jul 12 23:09:18 2009
@@ -293,10 +293,10 @@
// linkage!
Head = new GlobalVariable(M, StackEntryPtrTy, false,
GlobalValue::LinkOnceAnyLinkage,
- Constant::getNullValue(StackEntryPtrTy),
+ M.getContext().getNullValue(StackEntryPtrTy),
"llvm_gc_root_chain");
} else if (Head->hasExternalLinkage() && Head->isDeclaration()) {
- Head->setInitializer(Constant::getNullValue(StackEntryPtrTy));
+ Head->setInitializer(M.getContext().getNullValue(StackEntryPtrTy));
Head->setLinkage(GlobalValue::LinkOnceAnyLinkage);
}
Modified: llvm/trunk/lib/CodeGen/UnreachableBlockElim.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/UnreachableBlockElim.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/UnreachableBlockElim.cpp (original)
+++ llvm/trunk/lib/CodeGen/UnreachableBlockElim.cpp Sun Jul 12 23:09:18 2009
@@ -68,7 +68,7 @@
BasicBlock *BB = I;
DeadBlocks.push_back(BB);
while (PHINode *PN = dyn_cast<PHINode>(BB->begin())) {
- PN->replaceAllUsesWith(Constant::getNullValue(PN->getType()));
+ PN->replaceAllUsesWith(Context->getNullValue(PN->getType()));
BB->getInstList().pop_front();
}
for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI)
Modified: llvm/trunk/lib/Target/CBackend/CBackend.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/CBackend/CBackend.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/Target/CBackend/CBackend.cpp (original)
+++ llvm/trunk/lib/Target/CBackend/CBackend.cpp Sun Jul 12 23:09:18 2009
@@ -1239,7 +1239,7 @@
Out << '{';
if (AT->getNumElements()) {
Out << ' ';
- Constant *CZ = Constant::getNullValue(AT->getElementType());
+ Constant *CZ = Context->getNullValue(AT->getElementType());
printConstant(CZ, Static);
for (unsigned i = 1, e = AT->getNumElements(); i != e; ++i) {
Out << ", ";
@@ -1264,7 +1264,7 @@
assert(isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV));
const VectorType *VT = cast<VectorType>(CPV->getType());
Out << "{ ";
- Constant *CZ = Constant::getNullValue(VT->getElementType());
+ Constant *CZ = Context->getNullValue(VT->getElementType());
printConstant(CZ, Static);
for (unsigned i = 1, e = VT->getNumElements(); i != e; ++i) {
Out << ", ";
@@ -1286,10 +1286,10 @@
Out << '{';
if (ST->getNumElements()) {
Out << ' ';
- printConstant(Constant::getNullValue(ST->getElementType(0)), Static);
+ printConstant(Context->getNullValue(ST->getElementType(0)), Static);
for (unsigned i = 1, e = ST->getNumElements(); i != e; ++i) {
Out << ", ";
- printConstant(Constant::getNullValue(ST->getElementType(i)), Static);
+ printConstant(Context->getNullValue(ST->getElementType(i)), Static);
}
}
Out << " }";
@@ -2621,11 +2621,11 @@
// If this is a negation operation, print it out as such. For FP, we don't
// want to print "-0.0 - X".
- if (BinaryOperator::isNeg(&I)) {
+ if (BinaryOperator::isNeg(*Context, &I)) {
Out << "-(";
writeOperand(BinaryOperator::getNegArgument(cast<BinaryOperator>(&I)));
Out << ")";
- } else if (BinaryOperator::isFNeg(&I)) {
+ } else if (BinaryOperator::isFNeg(*Context, &I)) {
Out << "-(";
writeOperand(BinaryOperator::getFNegArgument(cast<BinaryOperator>(&I)));
Out << ")";
Modified: llvm/trunk/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp (original)
+++ llvm/trunk/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp Sun Jul 12 23:09:18 2009
@@ -541,7 +541,7 @@
// Fall Through
case GlobalValue::PrivateLinkage:
case GlobalValue::InternalLinkage:
- if (CVA && CVA->isCString())
+ if (CVA && CVA->isCString(GVar->getParent()->getContext()))
printSizeAndType = false;
break;
case GlobalValue::GhostLinkage:
Modified: llvm/trunk/lib/Target/Mips/MipsISelLowering.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/Mips/MipsISelLowering.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/Target/Mips/MipsISelLowering.cpp (original)
+++ llvm/trunk/lib/Target/Mips/MipsISelLowering.cpp Sun Jul 12 23:09:18 2009
@@ -227,7 +227,7 @@
if (GVA->hasInitializer() && GV->hasLocalLinkage()) {
Constant *C = GVA->getInitializer();
const ConstantArray *CVA = dyn_cast<ConstantArray>(C);
- if (CVA && CVA->isCString())
+ if (CVA && CVA->isCString(GV->getParent()->getContext()))
return false;
}
Modified: llvm/trunk/lib/Target/TargetAsmInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/TargetAsmInfo.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/Target/TargetAsmInfo.cpp (original)
+++ llvm/trunk/lib/Target/TargetAsmInfo.cpp Sun Jul 12 23:09:18 2009
@@ -170,11 +170,11 @@
return (C->isNullValue() && !GV->isConstant() && !NoZerosInBSS);
}
-static bool isConstantString(const Constant *C) {
+static bool isConstantString(LLVMContext &Context, const Constant *C) {
// First check: is we have constant array of i8 terminated with zero
const ConstantArray *CVA = dyn_cast<ConstantArray>(C);
// Check, if initializer is a null-terminated string
- if (CVA && CVA->isCString())
+ if (CVA && CVA->isCString(Context))
return true;
// Another possibility: [1 x i8] zeroinitializer
@@ -229,7 +229,7 @@
}
} else {
// Check, if initializer is a null-terminated string
- if (isConstantString(C))
+ if (isConstantString(GV->getParent()->getContext(), C))
return SectionKind::RODataMergeStr;
else
return SectionKind::RODataMergeConst;
Modified: llvm/trunk/lib/Target/X86/X86FastISel.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/X86/X86FastISel.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/Target/X86/X86FastISel.cpp (original)
+++ llvm/trunk/lib/Target/X86/X86FastISel.cpp Sun Jul 12 23:09:18 2009
@@ -272,7 +272,7 @@
const X86AddressMode &AM) {
// Handle 'null' like i32/i64 0.
if (isa<ConstantPointerNull>(Val))
- Val = Constant::getNullValue(TD.getIntPtrType());
+ Val = Context->getNullValue(TD.getIntPtrType());
// If this is a store of a simple constant, fold the constant into the store.
if (ConstantInt *CI = dyn_cast<ConstantInt>(Val)) {
@@ -672,7 +672,7 @@
// Handle 'null' like i32/i64 0.
if (isa<ConstantPointerNull>(Op1))
- Op1 = Constant::getNullValue(TD.getIntPtrType());
+ Op1 = Context->getNullValue(TD.getIntPtrType());
// We have two options: compare with register or immediate. If the RHS of
// the compare is an immediate that we can fold into this compare, use
Modified: llvm/trunk/lib/Target/X86/X86InstrInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/X86/X86InstrInfo.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/Target/X86/X86InstrInfo.cpp (original)
+++ llvm/trunk/lib/Target/X86/X86InstrInfo.cpp Sun Jul 12 23:09:18 2009
@@ -20,6 +20,7 @@
#include "X86TargetMachine.h"
#include "llvm/GlobalVariable.h"
#include "llvm/DerivedTypes.h"
+#include "llvm/LLVMContext.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/CodeGen/MachineConstantPool.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
@@ -2312,7 +2313,7 @@
MachineConstantPool &MCP = *MF.getConstantPool();
const VectorType *Ty = VectorType::get(Type::Int32Ty, 4);
Constant *C = LoadMI->getOpcode() == X86::V_SET0 ?
- ConstantVector::getNullValue(Ty) :
+ MF.getFunction()->getContext()->getNullValue(Ty) :
ConstantVector::getAllOnesValue(Ty);
unsigned CPI = MCP.getConstantPoolIndex(C, 16);
Modified: llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp Sun Jul 12 23:09:18 2009
@@ -408,9 +408,10 @@
// getComplexity: Assign a complexity or rank value to LLVM Values...
// 0 -> undef, 1 -> Const, 2 -> Other, 3 -> Arg, 3 -> Unary, 4 -> OtherInst
-static unsigned getComplexity(Value *V) {
+static unsigned getComplexity(LLVMContext *Context, Value *V) {
if (isa<Instruction>(V)) {
- if (BinaryOperator::isNeg(V) || BinaryOperator::isFNeg(V) ||
+ if (BinaryOperator::isNeg(*Context, V) ||
+ BinaryOperator::isFNeg(*Context, V) ||
BinaryOperator::isNot(V))
return 3;
return 4;
@@ -521,7 +522,8 @@
//
bool InstCombiner::SimplifyCommutative(BinaryOperator &I) {
bool Changed = false;
- if (getComplexity(I.getOperand(0)) < getComplexity(I.getOperand(1)))
+ if (getComplexity(Context, I.getOperand(0)) <
+ getComplexity(Context, I.getOperand(1)))
Changed = !I.swapOperands();
if (!I.isAssociative()) return Changed;
@@ -559,7 +561,8 @@
/// so that theyare listed from right (least complex) to left (most complex).
/// This puts constants before unary operators before binary operators.
bool InstCombiner::SimplifyCompare(CmpInst &I) {
- if (getComplexity(I.getOperand(0)) >= getComplexity(I.getOperand(1)))
+ if (getComplexity(Context, I.getOperand(0)) >=
+ getComplexity(Context, I.getOperand(1)))
return false;
I.swapOperands();
// Compare instructions are not associative so there's nothing else we can do.
@@ -570,7 +573,7 @@
// if the LHS is a constant zero (which is the 'negate' form).
//
static inline Value *dyn_castNegVal(Value *V, LLVMContext *Context) {
- if (BinaryOperator::isNeg(V))
+ if (BinaryOperator::isNeg(*Context, V))
return BinaryOperator::getNegArgument(V);
// Constants can be considered to be negated values if they can be folded.
@@ -589,7 +592,7 @@
// form).
//
static inline Value *dyn_castFNegVal(Value *V, LLVMContext *Context) {
- if (BinaryOperator::isFNeg(V))
+ if (BinaryOperator::isFNeg(*Context, V))
return BinaryOperator::getFNegArgument(V);
// Constants can be considered to be negated values if they can be folded.
@@ -2185,7 +2188,7 @@
if (Value *RHSV = dyn_castNegVal(RHS, Context)) {
Instruction *NewAdd = BinaryOperator::CreateAdd(LHSV, RHSV, "sum");
InsertNewInstBefore(NewAdd, I);
- return BinaryOperator::CreateNeg(NewAdd);
+ return BinaryOperator::CreateNeg(*Context, NewAdd);
}
}
@@ -2530,9 +2533,11 @@
if (BinaryOperator *Op1I = dyn_cast<BinaryOperator>(Op1)) {
if (Op1I->getOpcode() == Instruction::Add) {
if (Op1I->getOperand(0) == Op0) // X-(X+Y) == -Y
- return BinaryOperator::CreateNeg(Op1I->getOperand(1), I.getName());
+ return BinaryOperator::CreateNeg(*Context, Op1I->getOperand(1),
+ I.getName());
else if (Op1I->getOperand(1) == Op0) // X-(Y+X) == -Y
- return BinaryOperator::CreateNeg(Op1I->getOperand(0), I.getName());
+ return BinaryOperator::CreateNeg(*Context, Op1I->getOperand(0),
+ I.getName());
else if (ConstantInt *CI1 = dyn_cast<ConstantInt>(I.getOperand(0))) {
if (ConstantInt *CI2 = dyn_cast<ConstantInt>(Op1I->getOperand(1)))
// C1-(X+C2) --> (C1-C2)-X
@@ -2593,7 +2598,8 @@
return ReplaceInstUsesWith(I, Op0I->getOperand(0));
} else if (Op0I->getOpcode() == Instruction::Sub) {
if (Op0I->getOperand(0) == Op1) // (X-Y)-X == -Y
- return BinaryOperator::CreateNeg(Op0I->getOperand(1), I.getName());
+ return BinaryOperator::CreateNeg(*Context, Op0I->getOperand(1),
+ I.getName());
}
}
@@ -2619,9 +2625,11 @@
if (BinaryOperator *Op1I = dyn_cast<BinaryOperator>(Op1)) {
if (Op1I->getOpcode() == Instruction::FAdd) {
if (Op1I->getOperand(0) == Op0) // X-(X+Y) == -Y
- return BinaryOperator::CreateFNeg(Op1I->getOperand(1), I.getName());
+ return BinaryOperator::CreateFNeg(*Context, Op1I->getOperand(1),
+ I.getName());
else if (Op1I->getOperand(1) == Op0) // X-(Y+X) == -Y
- return BinaryOperator::CreateFNeg(Op1I->getOperand(0), I.getName());
+ return BinaryOperator::CreateFNeg(*Context, Op1I->getOperand(0),
+ I.getName());
}
}
@@ -2683,7 +2691,7 @@
if (CI->equalsInt(1)) // X * 1 == X
return ReplaceInstUsesWith(I, Op0);
if (CI->isAllOnesValue()) // X * -1 == 0 - X
- return BinaryOperator::CreateNeg(Op0, I.getName());
+ return BinaryOperator::CreateNeg(*Context, Op0, I.getName());
const APInt& Val = cast<ConstantInt>(CI)->getValue();
if (Val.isPowerOf2()) { // Replace X*(2^C) with X << C
@@ -2695,7 +2703,7 @@
if (ConstantVector *Op1V = dyn_cast<ConstantVector>(Op1)) {
if (Op1V->isAllOnesValue()) // X * -1 == 0 - X
- return BinaryOperator::CreateNeg(Op0, I.getName());
+ return BinaryOperator::CreateNeg(*Context, Op0, I.getName());
// As above, vector X*splat(1.0) -> X in all defined cases.
if (Constant *Splat = Op1V->getSplatValue()) {
@@ -3108,7 +3116,7 @@
if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) {
// sdiv X, -1 == -X
if (RHS->isAllOnesValue())
- return BinaryOperator::CreateNeg(Op0);
+ return BinaryOperator::CreateNeg(*Context, Op0);
}
// If the sign bits of both operands are zero (i.e. we can prove they are
@@ -4042,7 +4050,7 @@
ConstantInt *A = dyn_cast<ConstantInt>(Op0LHS);
if (!(A && A->isZero()) && // avoid infinite recursion.
MaskedValueIsZero(Op0LHS, Mask)) {
- Instruction *NewNeg = BinaryOperator::CreateNeg(Op0RHS);
+ Instruction *NewNeg = BinaryOperator::CreateNeg(*Context, Op0RHS);
InsertNewInstBefore(NewNeg, I);
return BinaryOperator::CreateAnd(NewNeg, AndRHS);
}
@@ -7094,7 +7102,7 @@
else if (Value *NegVal = dyn_castNegVal(BOp0, Context))
return new ICmpInst(*Context, ICI.getPredicate(), NegVal, BOp1);
else if (BO->hasOneUse()) {
- Instruction *Neg = BinaryOperator::CreateNeg(BOp1);
+ Instruction *Neg = BinaryOperator::CreateNeg(*Context, BOp1);
InsertNewInstBefore(Neg, ICI);
Neg->takeName(BO);
return new ICmpInst(*Context, ICI.getPredicate(), BOp0, Neg);
@@ -9587,7 +9595,8 @@
NegVal = Context->getConstantExprNeg(C);
} else {
NegVal = InsertNewInstBefore(
- BinaryOperator::CreateNeg(SubOp->getOperand(1), "tmp"), SI);
+ BinaryOperator::CreateNeg(*Context, SubOp->getOperand(1),
+ "tmp"), SI);
}
Value *NewTrueOp = OtherAddOp;
Modified: llvm/trunk/lib/Transforms/Scalar/PredicateSimplifier.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/PredicateSimplifier.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/PredicateSimplifier.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/PredicateSimplifier.cpp Sun Jul 12 23:09:18 2009
@@ -1341,6 +1341,7 @@
BasicBlock *TopBB;
Instruction *TopInst;
bool &modified;
+ LLVMContext *Context;
typedef InequalityGraph::Node Node;
@@ -1660,7 +1661,8 @@
Top(DTDFS->getNodeForBlock(TopBB)),
TopBB(TopBB),
TopInst(NULL),
- modified(modified)
+ modified(modified),
+ Context(TopBB->getContext())
{
assert(Top && "VRPSolver created for unreachable basic block.");
}
@@ -1760,7 +1762,7 @@
} break;
case Instruction::Or: {
// "or i32 %a, %b" EQ 0 then %a EQ 0 and %b EQ 0
- Constant *Zero = Constant::getNullValue(Ty);
+ Constant *Zero = Context->getNullValue(Ty);
if (Canonical == Zero) {
add(Zero, Op0, ICmpInst::ICMP_EQ, NewContext);
add(Zero, Op1, ICmpInst::ICMP_EQ, NewContext);
@@ -1783,10 +1785,10 @@
}
if (Canonical == LHS) {
if (isa<ConstantInt>(Canonical))
- add(RHS, Constant::getNullValue(Ty), ICmpInst::ICMP_EQ,
+ add(RHS, Context->getNullValue(Ty), ICmpInst::ICMP_EQ,
NewContext);
} else if (isRelatedBy(LHS, Canonical, ICmpInst::ICMP_NE)) {
- add(RHS, Constant::getNullValue(Ty), ICmpInst::ICMP_NE,
+ add(RHS, Context->getNullValue(Ty), ICmpInst::ICMP_NE,
NewContext);
}
} break;
@@ -1831,10 +1833,10 @@
}
// TODO: The GEPI indices are all zero. Copy from definition to operand,
// jumping the type plane as needed.
- if (isRelatedBy(GEPI, Constant::getNullValue(GEPI->getType()),
+ if (isRelatedBy(GEPI, Context->getNullValue(GEPI->getType()),
ICmpInst::ICMP_NE)) {
Value *Ptr = GEPI->getPointerOperand();
- add(Ptr, Constant::getNullValue(Ptr->getType()), ICmpInst::ICMP_NE,
+ add(Ptr, Context->getNullValue(Ptr->getType()), ICmpInst::ICMP_NE,
NewContext);
}
} else if (CastInst *CI = dyn_cast<CastInst>(I)) {
@@ -1888,7 +1890,7 @@
const Type *Ty = BO->getType();
assert(!Ty->isFPOrFPVector() && "Float in work queue!");
- Constant *Zero = Constant::getNullValue(Ty);
+ Constant *Zero = Context->getNullValue(Ty);
Constant *One = ConstantInt::get(Ty, 1);
ConstantInt *AllOnes = ConstantInt::getAllOnesValue(Ty);
@@ -2110,9 +2112,9 @@
// TODO: The GEPI indices are all zero. Copy from operand to definition,
// jumping the type plane as needed.
Value *Ptr = GEPI->getPointerOperand();
- if (isRelatedBy(Ptr, Constant::getNullValue(Ptr->getType()),
+ if (isRelatedBy(Ptr, Context->getNullValue(Ptr->getType()),
ICmpInst::ICMP_NE)) {
- add(GEPI, Constant::getNullValue(GEPI->getType()), ICmpInst::ICMP_NE,
+ add(GEPI, Context->getNullValue(GEPI->getType()), ICmpInst::ICMP_NE,
NewContext);
}
}
@@ -2496,7 +2498,8 @@
void PredicateSimplifier::Forwards::visitAllocaInst(AllocaInst &AI) {
VRPSolver VRP(VN, IG, UB, VR, PS->DTDFS, PS->modified, &AI);
- VRP.add(Constant::getNullValue(AI.getType()), &AI, ICmpInst::ICMP_NE);
+ VRP.add(AI.getParent()->getContext()->getNullValue(AI.getType()),
+ &AI, ICmpInst::ICMP_NE);
VRP.solve();
}
@@ -2506,7 +2509,8 @@
if (isa<Constant>(Ptr)) return;
VRPSolver VRP(VN, IG, UB, VR, PS->DTDFS, PS->modified, &LI);
- VRP.add(Constant::getNullValue(Ptr->getType()), Ptr, ICmpInst::ICMP_NE);
+ VRP.add(LI.getParent()->getContext()->getNullValue(Ptr->getType()),
+ Ptr, ICmpInst::ICMP_NE);
VRP.solve();
}
@@ -2515,7 +2519,8 @@
if (isa<Constant>(Ptr)) return;
VRPSolver VRP(VN, IG, UB, VR, PS->DTDFS, PS->modified, &SI);
- VRP.add(Constant::getNullValue(Ptr->getType()), Ptr, ICmpInst::ICMP_NE);
+ VRP.add(SI.getParent()->getContext()->getNullValue(Ptr->getType()),
+ Ptr, ICmpInst::ICMP_NE);
VRP.solve();
}
@@ -2550,8 +2555,8 @@
case Instruction::SDiv: {
Value *Divisor = BO.getOperand(1);
VRPSolver VRP(VN, IG, UB, VR, PS->DTDFS, PS->modified, &BO);
- VRP.add(Constant::getNullValue(Divisor->getType()), Divisor,
- ICmpInst::ICMP_NE);
+ VRP.add(BO.getParent()->getContext()->getNullValue(Divisor->getType()),
+ Divisor, ICmpInst::ICMP_NE);
VRP.solve();
break;
}
Modified: llvm/trunk/lib/Transforms/Scalar/Reassociate.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/Reassociate.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/Reassociate.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/Reassociate.cpp Sun Jul 12 23:09:18 2009
@@ -178,7 +178,7 @@
// If this is a not or neg instruction, do not count it for rank. This
// assures us that X and ~X will have the same rank.
if (!I->getType()->isInteger() ||
- (!BinaryOperator::isNot(I) && !BinaryOperator::isNeg(I)))
+ (!BinaryOperator::isNot(I) && !BinaryOperator::isNeg(*Context, I)))
++Rank;
//DOUT << "Calculated Rank[" << V->getName() << "] = "
@@ -264,12 +264,12 @@
// If this is a multiply expression tree and it contains internal negations,
// transform them into multiplies by -1 so they can be reassociated.
if (I->getOpcode() == Instruction::Mul) {
- if (!LHSBO && LHS->hasOneUse() && BinaryOperator::isNeg(LHS)) {
+ if (!LHSBO && LHS->hasOneUse() && BinaryOperator::isNeg(*Context, LHS)) {
LHS = LowerNegateToMultiply(cast<Instruction>(LHS),
ValueRankMap, Context);
LHSBO = isReassociableOp(LHS, Opcode);
}
- if (!RHSBO && RHS->hasOneUse() && BinaryOperator::isNeg(RHS)) {
+ if (!RHSBO && RHS->hasOneUse() && BinaryOperator::isNeg(*Context, RHS)) {
RHS = LowerNegateToMultiply(cast<Instruction>(RHS),
ValueRankMap, Context);
RHSBO = isReassociableOp(RHS, Opcode);
@@ -373,7 +373,7 @@
// version of the value is returned, and BI is left pointing at the instruction
// that should be processed next by the reassociation pass.
//
-static Value *NegateValue(Value *V, Instruction *BI) {
+static Value *NegateValue(LLVMContext *Context, Value *V, Instruction *BI) {
// We are trying to expose opportunity for reassociation. One of the things
// that we want to do to achieve this is to push a negation as deep into an
// expression chain as possible, to expose the add instructions. In practice,
@@ -386,8 +386,8 @@
if (Instruction *I = dyn_cast<Instruction>(V))
if (I->getOpcode() == Instruction::Add && I->hasOneUse()) {
// Push the negates through the add.
- I->setOperand(0, NegateValue(I->getOperand(0), BI));
- I->setOperand(1, NegateValue(I->getOperand(1), BI));
+ I->setOperand(0, NegateValue(Context, I->getOperand(0), BI));
+ I->setOperand(1, NegateValue(Context, I->getOperand(1), BI));
// We must move the add instruction here, because the neg instructions do
// not dominate the old add instruction in general. By moving it, we are
@@ -402,14 +402,14 @@
// Insert a 'neg' instruction that subtracts the value from zero to get the
// negation.
//
- return BinaryOperator::CreateNeg(V, V->getName() + ".neg", BI);
+ return BinaryOperator::CreateNeg(*Context, V, V->getName() + ".neg", BI);
}
/// ShouldBreakUpSubtract - Return true if we should break up this subtract of
/// X-Y into (X + -Y).
-static bool ShouldBreakUpSubtract(Instruction *Sub) {
+static bool ShouldBreakUpSubtract(LLVMContext *Context, Instruction *Sub) {
// If this is a negation, we can't split it up!
- if (BinaryOperator::isNeg(Sub))
+ if (BinaryOperator::isNeg(*Context, Sub))
return false;
// Don't bother to break this up unless either the LHS is an associable add or
@@ -431,7 +431,7 @@
/// BreakUpSubtract - If we have (X-Y), and if either X is an add, or if this is
/// only used by an add, transform this into (X+(0-Y)) to promote better
/// reassociation.
-static Instruction *BreakUpSubtract(Instruction *Sub,
+static Instruction *BreakUpSubtract(LLVMContext *Context, Instruction *Sub,
std::map<AssertingVH<>, unsigned> &ValueRankMap) {
// Convert a subtract into an add and a neg instruction... so that sub
// instructions can be commuted with other add instructions...
@@ -439,7 +439,7 @@
// Calculate the negative value of Operand 1 of the sub instruction...
// and set it as the RHS of the add instruction we just made...
//
- Value *NegVal = NegateValue(Sub->getOperand(1), Sub);
+ Value *NegVal = NegateValue(Context, Sub->getOperand(1), Sub);
Instruction *New =
BinaryOperator::CreateAdd(Sub->getOperand(0), NegVal, "", Sub);
New->takeName(Sub);
@@ -663,7 +663,7 @@
for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
assert(i < Ops.size());
// Check for X and -X in the operand list.
- if (BinaryOperator::isNeg(Ops[i].Op)) {
+ if (BinaryOperator::isNeg(*Context, Ops[i].Op)) {
Value *X = BinaryOperator::getNegArgument(Ops[i].Op);
unsigned FoundX = FindInOperandList(Ops, i, X);
if (FoundX != i) {
@@ -798,10 +798,10 @@
// If this is a subtract instruction which is not already in negate form,
// see if we can convert it to X+-Y.
if (BI->getOpcode() == Instruction::Sub) {
- if (ShouldBreakUpSubtract(BI)) {
- BI = BreakUpSubtract(BI, ValueRankMap);
+ if (ShouldBreakUpSubtract(Context, BI)) {
+ BI = BreakUpSubtract(Context, BI, ValueRankMap);
MadeChange = true;
- } else if (BinaryOperator::isNeg(BI)) {
+ } else if (BinaryOperator::isNeg(*Context, BI)) {
// Otherwise, this is a negation. See if the operand is a multiply tree
// and if this is not an inner node of a multiply tree.
if (isReassociableOp(BI->getOperand(1), Instruction::Mul) &&
Modified: llvm/trunk/lib/Transforms/Utils/LowerInvoke.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/LowerInvoke.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/LowerInvoke.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/LowerInvoke.cpp Sun Jul 12 23:09:18 2009
@@ -251,7 +251,7 @@
// Insert a return instruction. This really should be a "barrier", as it
// is unreachable.
ReturnInst::Create(F.getReturnType() == Type::VoidTy ? 0 :
- Constant::getNullValue(F.getReturnType()), UI);
+ Context->getNullValue(F.getReturnType()), UI);
// Remove the unwind instruction now.
BB->getInstList().erase(UI);
@@ -285,7 +285,7 @@
BasicBlock::iterator NI = II->getNormalDest()->getFirstNonPHI();
// nonvolatile.
- new StoreInst(Constant::getNullValue(Type::Int32Ty), InvokeNum, false, NI);
+ new StoreInst(Context->getNullValue(Type::Int32Ty), InvokeNum, false, NI);
// Add a switch case to our unwind block.
CatchSwitch->addCase(InvokeNoC, II->getUnwindDest());
@@ -473,7 +473,7 @@
new AllocaInst(JBLinkTy, 0, Align, "jblink", F.begin()->begin());
std::vector<Value*> Idx;
- Idx.push_back(Constant::getNullValue(Type::Int32Ty));
+ Idx.push_back(Context->getNullValue(Type::Int32Ty));
Idx.push_back(ConstantInt::get(Type::Int32Ty, 1));
OldJmpBufPtr = GetElementPtrInst::Create(JmpBuf, Idx.begin(), Idx.end(),
"OldBuf", EntryBB->getTerminator());
@@ -525,7 +525,7 @@
// Compare the return value to zero.
Value *IsNormal = new ICmpInst(EntryBB->getTerminator(),
ICmpInst::ICMP_EQ, SJRet,
- Constant::getNullValue(SJRet->getType()),
+ Context->getNullValue(SJRet->getType()),
"notunwind");
// Nuke the uncond branch.
EntryBB->getTerminator()->eraseFromParent();
@@ -559,14 +559,14 @@
// Load the JBList, if it's null, then there was no catch!
Value *NotNull = new ICmpInst(*UnwindHandler, ICmpInst::ICMP_NE, BufPtr,
- Constant::getNullValue(BufPtr->getType()),
+ Context->getNullValue(BufPtr->getType()),
"notnull");
BranchInst::Create(UnwindBlock, TermBlock, NotNull, UnwindHandler);
// Create the block to do the longjmp.
// Get a pointer to the jmpbuf and longjmp.
std::vector<Value*> Idx;
- Idx.push_back(Constant::getNullValue(Type::Int32Ty));
+ Idx.push_back(Context->getNullValue(Type::Int32Ty));
Idx.push_back(ConstantInt::get(Type::Int32Ty, 0));
Idx[0] = GetElementPtrInst::Create(BufPtr, Idx.begin(), Idx.end(), "JmpBuf",
UnwindBlock);
Modified: llvm/trunk/lib/VMCore/ConstantFold.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/VMCore/ConstantFold.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/VMCore/ConstantFold.cpp (original)
+++ llvm/trunk/lib/VMCore/ConstantFold.cpp Sun Jul 12 23:09:18 2009
@@ -24,6 +24,7 @@
#include "llvm/DerivedTypes.h"
#include "llvm/Function.h"
#include "llvm/GlobalAlias.h"
+#include "llvm/LLVMContext.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/ErrorHandling.h"
@@ -40,7 +41,7 @@
/// BitCastConstantVector - Convert the specified ConstantVector node to the
/// specified vector type. At this point, we know that the elements of the
/// input vector constant are all simple integer or FP values.
-static Constant *BitCastConstantVector(ConstantVector *CV,
+static Constant *BitCastConstantVector(LLVMContext &Context, ConstantVector *CV,
const VectorType *DstTy) {
// If this cast changes element count then we can't handle it here:
// doing so requires endianness information. This should be handled by
@@ -60,8 +61,9 @@
std::vector<Constant*> Result;
const Type *DstEltTy = DstTy->getElementType();
for (unsigned i = 0; i != NumElts; ++i)
- Result.push_back(ConstantExpr::getBitCast(CV->getOperand(i), DstEltTy));
- return ConstantVector::get(Result);
+ Result.push_back(Context.getConstantExprBitCast(CV->getOperand(i),
+ DstEltTy));
+ return Context.getConstantVector(Result);
}
/// This function determines which opcode to use to fold two constant cast
@@ -89,7 +91,8 @@
Type::Int64Ty);
}
-static Constant *FoldBitCast(Constant *V, const Type *DestTy) {
+static Constant *FoldBitCast(LLVMContext &Context,
+ Constant *V, const Type *DestTy) {
const Type *SrcTy = V->getType();
if (SrcTy == DestTy)
return V; // no-op cast
@@ -100,13 +103,13 @@
if (const PointerType *DPTy = dyn_cast<PointerType>(DestTy))
if (PTy->getAddressSpace() == DPTy->getAddressSpace()) {
SmallVector<Value*, 8> IdxList;
- IdxList.push_back(Constant::getNullValue(Type::Int32Ty));
+ IdxList.push_back(Context.getNullValue(Type::Int32Ty));
const Type *ElTy = PTy->getElementType();
while (ElTy != DPTy->getElementType()) {
if (const StructType *STy = dyn_cast<StructType>(ElTy)) {
if (STy->getNumElements() == 0) break;
ElTy = STy->getElementType(0);
- IdxList.push_back(Constant::getNullValue(Type::Int32Ty));
+ IdxList.push_back(Context.getNullValue(Type::Int32Ty));
} else if (const SequentialType *STy =
dyn_cast<SequentialType>(ElTy)) {
if (isa<PointerType>(ElTy)) break; // Can't index into pointers!
@@ -118,7 +121,8 @@
}
if (ElTy == DPTy->getElementType())
- return ConstantExpr::getGetElementPtr(V, &IdxList[0], IdxList.size());
+ return Context.getConstantExprGetElementPtr(V, &IdxList[0],
+ IdxList.size());
}
// Handle casts from one vector constant to another. We know that the src
@@ -130,23 +134,24 @@
SrcTy = NULL;
// First, check for null. Undef is already handled.
if (isa<ConstantAggregateZero>(V))
- return Constant::getNullValue(DestTy);
+ return Context.getNullValue(DestTy);
if (ConstantVector *CV = dyn_cast<ConstantVector>(V))
- return BitCastConstantVector(CV, DestPTy);
+ return BitCastConstantVector(Context, CV, DestPTy);
}
// Canonicalize scalar-to-vector bitcasts into vector-to-vector bitcasts
// This allows for other simplifications (although some of them
// can only be handled by Analysis/ConstantFolding.cpp).
if (isa<ConstantInt>(V) || isa<ConstantFP>(V))
- return ConstantExpr::getBitCast(ConstantVector::get(&V, 1), DestPTy);
+ return Context.getConstantExprBitCast(
+ Context.getConstantVector(&V, 1), DestPTy);
}
// Finally, implement bitcast folding now. The code below doesn't handle
// bitcast right.
if (isa<ConstantPointerNull>(V)) // ptr->ptr cast.
- return ConstantPointerNull::get(cast<PointerType>(DestTy));
+ return Context.getConstantPointerNull(cast<PointerType>(DestTy));
// Handle integral constant input.
if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
@@ -156,7 +161,7 @@
return V;
if (DestTy->isFloatingPoint())
- return ConstantFP::get(APFloat(CI->getValue(),
+ return Context.getConstantFP(APFloat(CI->getValue(),
DestTy != Type::PPC_FP128Ty));
// Otherwise, can't fold this (vector?)
@@ -166,13 +171,14 @@
// Handle ConstantFP input.
if (const ConstantFP *FP = dyn_cast<ConstantFP>(V))
// FP -> Integral.
- return ConstantInt::get(FP->getValueAPF().bitcastToAPInt());
+ return Context.getConstantInt(FP->getValueAPF().bitcastToAPInt());
return 0;
}
-Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
+Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context,
+ unsigned opc, const Constant *V,
const Type *DestTy) {
if (isa<UndefValue>(V)) {
// zext(undef) = 0, because the top bits will be zero.
@@ -180,8 +186,8 @@
// [us]itofp(undef) = 0, because the result value is bounded.
if (opc == Instruction::ZExt || opc == Instruction::SExt ||
opc == Instruction::UIToFP || opc == Instruction::SIToFP)
- return Constant::getNullValue(DestTy);
- return UndefValue::get(DestTy);
+ return Context.getNullValue(DestTy);
+ return Context.getUndef(DestTy);
}
// No compile-time operations on this type yet.
if (V->getType() == Type::PPC_FP128Ty || DestTy == Type::PPC_FP128Ty)
@@ -193,7 +199,7 @@
if (CE->isCast()) {
// Try hard to fold cast of cast because they are often eliminable.
if (unsigned newOpc = foldConstantCastPair(opc, CE, DestTy))
- return ConstantExpr::getCast(newOpc, CE->getOperand(0), DestTy);
+ return Context.getConstantExprCast(newOpc, CE->getOperand(0), DestTy);
} else if (CE->getOpcode() == Instruction::GetElementPtr) {
// If all of the indexes in the GEP are null values, there is no pointer
// adjustment going on. We might as well cast the source pointer.
@@ -205,7 +211,7 @@
}
if (isAllNull)
// This is casting one pointer type to another, always BitCast
- return ConstantExpr::getPointerCast(CE->getOperand(0), DestTy);
+ return Context.getConstantExprPointerCast(CE->getOperand(0), DestTy);
}
}
@@ -220,9 +226,9 @@
const VectorType *DestVecTy = cast<VectorType>(DestTy);
const Type *DstEltTy = DestVecTy->getElementType();
for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i)
- res.push_back(ConstantExpr::getCast(opc,
+ res.push_back(Context.getConstantExprCast(opc,
CV->getOperand(i), DstEltTy));
- return ConstantVector::get(DestVecTy, res);
+ return Context.getConstantVector(DestVecTy, res);
}
// We actually have to do a cast now. Perform the cast according to the
@@ -239,7 +245,7 @@
DestTy == Type::FP128Ty ? APFloat::IEEEquad :
APFloat::Bogus,
APFloat::rmNearestTiesToEven, &ignored);
- return ConstantFP::get(Val);
+ return Context.getConstantFP(Val);
}
return 0; // Can't fold.
case Instruction::FPToUI:
@@ -252,16 +258,16 @@
(void) V.convertToInteger(x, DestBitWidth, opc==Instruction::FPToSI,
APFloat::rmTowardZero, &ignored);
APInt Val(DestBitWidth, 2, x);
- return ConstantInt::get(Val);
+ return Context.getConstantInt(Val);
}
return 0; // Can't fold.
case Instruction::IntToPtr: //always treated as unsigned
if (V->isNullValue()) // Is it an integral null value?
- return ConstantPointerNull::get(cast<PointerType>(DestTy));
+ return Context.getConstantPointerNull(cast<PointerType>(DestTy));
return 0; // Other pointer types cannot be casted
case Instruction::PtrToInt: // always treated as unsigned
if (V->isNullValue()) // is it a null pointer value?
- return ConstantInt::get(DestTy, 0);
+ return Context.getConstantInt(DestTy, 0);
return 0; // Other pointer types cannot be casted
case Instruction::UIToFP:
case Instruction::SIToFP:
@@ -273,7 +279,7 @@
(void)apf.convertFromAPInt(api,
opc==Instruction::SIToFP,
APFloat::rmNearestTiesToEven);
- return ConstantFP::get(apf);
+ return Context.getConstantFP(apf);
}
return 0;
case Instruction::ZExt:
@@ -281,7 +287,7 @@
uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
APInt Result(CI->getValue());
Result.zext(BitWidth);
- return ConstantInt::get(Result);
+ return Context.getConstantInt(Result);
}
return 0;
case Instruction::SExt:
@@ -289,7 +295,7 @@
uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
APInt Result(CI->getValue());
Result.sext(BitWidth);
- return ConstantInt::get(Result);
+ return Context.getConstantInt(Result);
}
return 0;
case Instruction::Trunc:
@@ -297,11 +303,11 @@
uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
APInt Result(CI->getValue());
Result.trunc(BitWidth);
- return ConstantInt::get(Result);
+ return Context.getConstantInt(Result);
}
return 0;
case Instruction::BitCast:
- return FoldBitCast(const_cast<Constant*>(V), DestTy);
+ return FoldBitCast(Context, const_cast<Constant*>(V), DestTy);
default:
assert(!"Invalid CE CastInst opcode");
break;
@@ -311,7 +317,8 @@
return 0;
}
-Constant *llvm::ConstantFoldSelectInstruction(const Constant *Cond,
+Constant *llvm::ConstantFoldSelectInstruction(LLVMContext&,
+ const Constant *Cond,
const Constant *V1,
const Constant *V2) {
if (const ConstantInt *CB = dyn_cast<ConstantInt>(Cond))
@@ -324,12 +331,13 @@
return 0;
}
-Constant *llvm::ConstantFoldExtractElementInstruction(const Constant *Val,
+Constant *llvm::ConstantFoldExtractElementInstruction(LLVMContext &Context,
+ const Constant *Val,
const Constant *Idx) {
if (isa<UndefValue>(Val)) // ee(undef, x) -> undef
- return UndefValue::get(cast<VectorType>(Val->getType())->getElementType());
+ return Context.getUndef(cast<VectorType>(Val->getType())->getElementType());
if (Val->isNullValue()) // ee(zero, x) -> zero
- return Constant::getNullValue(
+ return Context.getNullValue(
cast<VectorType>(Val->getType())->getElementType());
if (const ConstantVector *CVal = dyn_cast<ConstantVector>(Val)) {
@@ -343,7 +351,8 @@
return 0;
}
-Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val,
+Constant *llvm::ConstantFoldInsertElementInstruction(LLVMContext &Context,
+ const Constant *Val,
const Constant *Elt,
const Constant *Idx) {
const ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx);
@@ -362,10 +371,10 @@
Ops.reserve(numOps);
for (unsigned i = 0; i < numOps; ++i) {
const Constant *Op =
- (idxVal == i) ? Elt : UndefValue::get(Elt->getType());
+ (idxVal == i) ? Elt : Context.getUndef(Elt->getType());
Ops.push_back(const_cast<Constant*>(Op));
}
- return ConstantVector::get(Ops);
+ return Context.getConstantVector(Ops);
}
if (isa<ConstantAggregateZero>(Val)) {
// Insertion of scalar constant into vector aggregate zero
@@ -380,10 +389,10 @@
Ops.reserve(numOps);
for (unsigned i = 0; i < numOps; ++i) {
const Constant *Op =
- (idxVal == i) ? Elt : Constant::getNullValue(Elt->getType());
+ (idxVal == i) ? Elt : Context.getNullValue(Elt->getType());
Ops.push_back(const_cast<Constant*>(Op));
}
- return ConstantVector::get(Ops);
+ return Context.getConstantVector(Ops);
}
if (const ConstantVector *CVal = dyn_cast<ConstantVector>(Val)) {
// Insertion of scalar constant into vector constant
@@ -394,7 +403,7 @@
(idxVal == i) ? Elt : cast<Constant>(CVal->getOperand(i));
Ops.push_back(const_cast<Constant*>(Op));
}
- return ConstantVector::get(Ops);
+ return Context.getConstantVector(Ops);
}
return 0;
@@ -402,23 +411,25 @@
/// GetVectorElement - If C is a ConstantVector, ConstantAggregateZero or Undef
/// return the specified element value. Otherwise return null.
-static Constant *GetVectorElement(const Constant *C, unsigned EltNo) {
+static Constant *GetVectorElement(LLVMContext &Context, const Constant *C,
+ unsigned EltNo) {
if (const ConstantVector *CV = dyn_cast<ConstantVector>(C))
return CV->getOperand(EltNo);
const Type *EltTy = cast<VectorType>(C->getType())->getElementType();
if (isa<ConstantAggregateZero>(C))
- return Constant::getNullValue(EltTy);
+ return Context.getNullValue(EltTy);
if (isa<UndefValue>(C))
- return UndefValue::get(EltTy);
+ return Context.getUndef(EltTy);
return 0;
}
-Constant *llvm::ConstantFoldShuffleVectorInstruction(const Constant *V1,
+Constant *llvm::ConstantFoldShuffleVectorInstruction(LLVMContext &Context,
+ const Constant *V1,
const Constant *V2,
const Constant *Mask) {
// Undefined shuffle mask -> undefined value.
- if (isa<UndefValue>(Mask)) return UndefValue::get(V1->getType());
+ if (isa<UndefValue>(Mask)) return Context.getUndef(V1->getType());
unsigned MaskNumElts = cast<VectorType>(Mask->getType())->getNumElements();
unsigned SrcNumElts = cast<VectorType>(V1->getType())->getNumElements();
@@ -427,19 +438,19 @@
// Loop over the shuffle mask, evaluating each element.
SmallVector<Constant*, 32> Result;
for (unsigned i = 0; i != MaskNumElts; ++i) {
- Constant *InElt = GetVectorElement(Mask, i);
+ Constant *InElt = GetVectorElement(Context, Mask, i);
if (InElt == 0) return 0;
if (isa<UndefValue>(InElt))
- InElt = UndefValue::get(EltTy);
+ InElt = Context.getUndef(EltTy);
else if (ConstantInt *CI = dyn_cast<ConstantInt>(InElt)) {
unsigned Elt = CI->getZExtValue();
if (Elt >= SrcNumElts*2)
- InElt = UndefValue::get(EltTy);
+ InElt = Context.getUndef(EltTy);
else if (Elt >= SrcNumElts)
- InElt = GetVectorElement(V2, Elt - SrcNumElts);
+ InElt = GetVectorElement(Context, V2, Elt - SrcNumElts);
else
- InElt = GetVectorElement(V1, Elt);
+ InElt = GetVectorElement(Context, V1, Elt);
if (InElt == 0) return 0;
} else {
// Unknown value.
@@ -448,10 +459,11 @@
Result.push_back(InElt);
}
- return ConstantVector::get(&Result[0], Result.size());
+ return Context.getConstantVector(&Result[0], Result.size());
}
-Constant *llvm::ConstantFoldExtractValueInstruction(const Constant *Agg,
+Constant *llvm::ConstantFoldExtractValueInstruction(LLVMContext &Context,
+ const Constant *Agg,
const unsigned *Idxs,
unsigned NumIdx) {
// Base case: no indices, so return the entire value.
@@ -459,22 +471,23 @@
return const_cast<Constant *>(Agg);
if (isa<UndefValue>(Agg)) // ev(undef, x) -> undef
- return UndefValue::get(ExtractValueInst::getIndexedType(Agg->getType(),
+ return Context.getUndef(ExtractValueInst::getIndexedType(Agg->getType(),
Idxs,
Idxs + NumIdx));
if (isa<ConstantAggregateZero>(Agg)) // ev(0, x) -> 0
return
- Constant::getNullValue(ExtractValueInst::getIndexedType(Agg->getType(),
+ Context.getNullValue(ExtractValueInst::getIndexedType(Agg->getType(),
Idxs,
Idxs + NumIdx));
// Otherwise recurse.
- return ConstantFoldExtractValueInstruction(Agg->getOperand(*Idxs),
+ return ConstantFoldExtractValueInstruction(Context, Agg->getOperand(*Idxs),
Idxs+1, NumIdx-1);
}
-Constant *llvm::ConstantFoldInsertValueInstruction(const Constant *Agg,
+Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context,
+ const Constant *Agg,
const Constant *Val,
const unsigned *Idxs,
unsigned NumIdx) {
@@ -500,15 +513,15 @@
const Type *MemberTy = AggTy->getTypeAtIndex(i);
const Constant *Op =
(*Idxs == i) ?
- ConstantFoldInsertValueInstruction(UndefValue::get(MemberTy),
+ ConstantFoldInsertValueInstruction(Context, Context.getUndef(MemberTy),
Val, Idxs+1, NumIdx-1) :
- UndefValue::get(MemberTy);
+ Context.getUndef(MemberTy);
Ops[i] = const_cast<Constant*>(Op);
}
if (isa<StructType>(AggTy))
- return ConstantStruct::get(Ops);
+ return Context.getConstantStruct(Ops);
else
- return ConstantArray::get(cast<ArrayType>(AggTy), Ops);
+ return Context.getConstantArray(cast<ArrayType>(AggTy), Ops);
}
if (isa<ConstantAggregateZero>(Agg)) {
// Insertion of constant into aggregate zero
@@ -528,15 +541,16 @@
const Type *MemberTy = AggTy->getTypeAtIndex(i);
const Constant *Op =
(*Idxs == i) ?
- ConstantFoldInsertValueInstruction(Constant::getNullValue(MemberTy),
+ ConstantFoldInsertValueInstruction(Context,
+ Context.getNullValue(MemberTy),
Val, Idxs+1, NumIdx-1) :
- Constant::getNullValue(MemberTy);
+ Context.getNullValue(MemberTy);
Ops[i] = const_cast<Constant*>(Op);
}
if (isa<StructType>(AggTy))
- return ConstantStruct::get(Ops);
+ return Context.getConstantStruct(Ops);
else
- return ConstantArray::get(cast<ArrayType>(AggTy), Ops);
+ return Context.getConstantArray(cast<ArrayType>(AggTy), Ops);
}
if (isa<ConstantStruct>(Agg) || isa<ConstantArray>(Agg)) {
// Insertion of constant into aggregate constant
@@ -544,16 +558,16 @@
for (unsigned i = 0; i < Agg->getNumOperands(); ++i) {
const Constant *Op =
(*Idxs == i) ?
- ConstantFoldInsertValueInstruction(Agg->getOperand(i),
+ ConstantFoldInsertValueInstruction(Context, Agg->getOperand(i),
Val, Idxs+1, NumIdx-1) :
Agg->getOperand(i);
Ops[i] = const_cast<Constant*>(Op);
}
Constant *C;
if (isa<StructType>(Agg->getType()))
- C = ConstantStruct::get(Ops);
+ C = Context.getConstantStruct(Ops);
else
- C = ConstantArray::get(cast<ArrayType>(Agg->getType()), Ops);
+ C = Context.getConstantArray(cast<ArrayType>(Agg->getType()), Ops);
return C;
}
@@ -564,22 +578,23 @@
/// function pointer to each element pair, producing a new ConstantVector
/// constant. Either or both of V1 and V2 may be NULL, meaning a
/// ConstantAggregateZero operand.
-static Constant *EvalVectorOp(const ConstantVector *V1,
+static Constant *EvalVectorOp(LLVMContext &Context, const ConstantVector *V1,
const ConstantVector *V2,
const VectorType *VTy,
Constant *(*FP)(Constant*, Constant*)) {
std::vector<Constant*> Res;
const Type *EltTy = VTy->getElementType();
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
- const Constant *C1 = V1 ? V1->getOperand(i) : Constant::getNullValue(EltTy);
- const Constant *C2 = V2 ? V2->getOperand(i) : Constant::getNullValue(EltTy);
+ const Constant *C1 = V1 ? V1->getOperand(i) : Context.getNullValue(EltTy);
+ const Constant *C2 = V2 ? V2->getOperand(i) : Context.getNullValue(EltTy);
Res.push_back(FP(const_cast<Constant*>(C1),
const_cast<Constant*>(C2)));
}
- return ConstantVector::get(Res);
+ return Context.getConstantVector(Res);
}
-Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode,
+Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context,
+ unsigned Opcode,
const Constant *C1,
const Constant *C2) {
// No compile-time operations on this type yet.
@@ -593,29 +608,29 @@
if (isa<UndefValue>(C1) && isa<UndefValue>(C2))
// Handle undef ^ undef -> 0 special case. This is a common
// idiom (misuse).
- return Constant::getNullValue(C1->getType());
+ return Context.getNullValue(C1->getType());
// Fallthrough
case Instruction::Add:
case Instruction::Sub:
- return UndefValue::get(C1->getType());
+ return Context.getUndef(C1->getType());
case Instruction::Mul:
case Instruction::And:
- return Constant::getNullValue(C1->getType());
+ return Context.getNullValue(C1->getType());
case Instruction::UDiv:
case Instruction::SDiv:
case Instruction::URem:
case Instruction::SRem:
if (!isa<UndefValue>(C2)) // undef / X -> 0
- return Constant::getNullValue(C1->getType());
+ return Context.getNullValue(C1->getType());
return const_cast<Constant*>(C2); // X / undef -> undef
case Instruction::Or: // X | undef -> -1
if (const VectorType *PTy = dyn_cast<VectorType>(C1->getType()))
- return ConstantVector::getAllOnesValue(PTy);
- return ConstantInt::getAllOnesValue(C1->getType());
+ return Context.getAllOnesValue(PTy);
+ return Context.getAllOnesValue(C1->getType());
case Instruction::LShr:
if (isa<UndefValue>(C2) && isa<UndefValue>(C1))
return const_cast<Constant*>(C1); // undef lshr undef -> undef
- return Constant::getNullValue(C1->getType()); // X lshr undef -> 0
+ return Context.getNullValue(C1->getType()); // X lshr undef -> 0
// undef lshr X -> 0
case Instruction::AShr:
if (!isa<UndefValue>(C2))
@@ -626,7 +641,7 @@
return const_cast<Constant*>(C1); // X ashr undef --> X
case Instruction::Shl:
// undef << X -> 0 or X << undef -> 0
- return Constant::getNullValue(C1->getType());
+ return Context.getNullValue(C1->getType());
}
}
@@ -649,14 +664,14 @@
if (CI2->equalsInt(1))
return const_cast<Constant*>(C1); // X / 1 == X
if (CI2->equalsInt(0))
- return UndefValue::get(CI2->getType()); // X / 0 == undef
+ return Context.getUndef(CI2->getType()); // X / 0 == undef
break;
case Instruction::URem:
case Instruction::SRem:
if (CI2->equalsInt(1))
- return Constant::getNullValue(CI2->getType()); // X % 1 == 0
+ return Context.getNullValue(CI2->getType()); // X % 1 == 0
if (CI2->equalsInt(0))
- return UndefValue::get(CI2->getType()); // X % 0 == undef
+ return Context.getUndef(CI2->getType()); // X % 0 == undef
break;
case Instruction::And:
if (CI2->isZero()) return const_cast<Constant*>(C2); // X & 0 == 0
@@ -691,7 +706,7 @@
// If checking bits we know are clear, return zero.
if ((CI2->getValue() & BitsNotSet) == CI2->getValue())
- return Constant::getNullValue(CI2->getType());
+ return Context.getNullValue(CI2->getType());
}
}
}
@@ -708,8 +723,8 @@
// ashr (zext C to Ty), C2 -> lshr (zext C, CSA), C2
if (const ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1))
if (CE1->getOpcode() == Instruction::ZExt) // Top bits known zero.
- return ConstantExpr::getLShr(const_cast<Constant*>(C1),
- const_cast<Constant*>(C2));
+ return Context.getConstantExprLShr(const_cast<Constant*>(C1),
+ const_cast<Constant*>(C2));
break;
}
}
@@ -724,53 +739,53 @@
default:
break;
case Instruction::Add:
- return ConstantInt::get(C1V + C2V);
+ return Context.getConstantInt(C1V + C2V);
case Instruction::Sub:
- return ConstantInt::get(C1V - C2V);
+ return Context.getConstantInt(C1V - C2V);
case Instruction::Mul:
- return ConstantInt::get(C1V * C2V);
+ return Context.getConstantInt(C1V * C2V);
case Instruction::UDiv:
assert(!CI2->isNullValue() && "Div by zero handled above");
- return ConstantInt::get(C1V.udiv(C2V));
+ return Context.getConstantInt(C1V.udiv(C2V));
case Instruction::SDiv:
assert(!CI2->isNullValue() && "Div by zero handled above");
if (C2V.isAllOnesValue() && C1V.isMinSignedValue())
- return UndefValue::get(CI1->getType()); // MIN_INT / -1 -> undef
- return ConstantInt::get(C1V.sdiv(C2V));
+ return Context.getUndef(CI1->getType()); // MIN_INT / -1 -> undef
+ return Context.getConstantInt(C1V.sdiv(C2V));
case Instruction::URem:
assert(!CI2->isNullValue() && "Div by zero handled above");
- return ConstantInt::get(C1V.urem(C2V));
+ return Context.getConstantInt(C1V.urem(C2V));
case Instruction::SRem:
assert(!CI2->isNullValue() && "Div by zero handled above");
if (C2V.isAllOnesValue() && C1V.isMinSignedValue())
- return UndefValue::get(CI1->getType()); // MIN_INT % -1 -> undef
- return ConstantInt::get(C1V.srem(C2V));
+ return Context.getUndef(CI1->getType()); // MIN_INT % -1 -> undef
+ return Context.getConstantInt(C1V.srem(C2V));
case Instruction::And:
- return ConstantInt::get(C1V & C2V);
+ return Context.getConstantInt(C1V & C2V);
case Instruction::Or:
- return ConstantInt::get(C1V | C2V);
+ return Context.getConstantInt(C1V | C2V);
case Instruction::Xor:
- return ConstantInt::get(C1V ^ C2V);
+ return Context.getConstantInt(C1V ^ C2V);
case Instruction::Shl: {
uint32_t shiftAmt = C2V.getZExtValue();
if (shiftAmt < C1V.getBitWidth())
- return ConstantInt::get(C1V.shl(shiftAmt));
+ return Context.getConstantInt(C1V.shl(shiftAmt));
else
- return UndefValue::get(C1->getType()); // too big shift is undef
+ return Context.getUndef(C1->getType()); // too big shift is undef
}
case Instruction::LShr: {
uint32_t shiftAmt = C2V.getZExtValue();
if (shiftAmt < C1V.getBitWidth())
- return ConstantInt::get(C1V.lshr(shiftAmt));
+ return Context.getConstantInt(C1V.lshr(shiftAmt));
else
- return UndefValue::get(C1->getType()); // too big shift is undef
+ return Context.getUndef(C1->getType()); // too big shift is undef
}
case Instruction::AShr: {
uint32_t shiftAmt = C2V.getZExtValue();
if (shiftAmt < C1V.getBitWidth())
- return ConstantInt::get(C1V.ashr(shiftAmt));
+ return Context.getConstantInt(C1V.ashr(shiftAmt));
else
- return UndefValue::get(C1->getType()); // too big shift is undef
+ return Context.getUndef(C1->getType()); // too big shift is undef
}
}
}
@@ -798,19 +813,19 @@
break;
case Instruction::FAdd:
(void)C3V.add(C2V, APFloat::rmNearestTiesToEven);
- return ConstantFP::get(C3V);
+ return Context.getConstantFP(C3V);
case Instruction::FSub:
(void)C3V.subtract(C2V, APFloat::rmNearestTiesToEven);
- return ConstantFP::get(C3V);
+ return Context.getConstantFP(C3V);
case Instruction::FMul:
(void)C3V.multiply(C2V, APFloat::rmNearestTiesToEven);
- return ConstantFP::get(C3V);
+ return Context.getConstantFP(C3V);
case Instruction::FDiv:
(void)C3V.divide(C2V, APFloat::rmNearestTiesToEven);
- return ConstantFP::get(C3V);
+ return Context.getConstantFP(C3V);
case Instruction::FRem:
(void)C3V.mod(C2V, APFloat::rmNearestTiesToEven);
- return ConstantFP::get(C3V);
+ return Context.getConstantFP(C3V);
}
}
} else if (const VectorType *VTy = dyn_cast<VectorType>(C1->getType())) {
@@ -822,41 +837,41 @@
default:
break;
case Instruction::Add:
- return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getAdd);
+ return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getAdd);
case Instruction::FAdd:
- return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFAdd);
+ return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFAdd);
case Instruction::Sub:
- return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getSub);
+ return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getSub);
case Instruction::FSub:
- return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFSub);
+ return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFSub);
case Instruction::Mul:
- return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getMul);
+ return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getMul);
case Instruction::FMul:
- return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFMul);
+ return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFMul);
case Instruction::UDiv:
- return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getUDiv);
+ return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getUDiv);
case Instruction::SDiv:
- return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getSDiv);
+ return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getSDiv);
case Instruction::FDiv:
- return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFDiv);
+ return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFDiv);
case Instruction::URem:
- return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getURem);
+ return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getURem);
case Instruction::SRem:
- return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getSRem);
+ return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getSRem);
case Instruction::FRem:
- return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFRem);
+ return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFRem);
case Instruction::And:
- return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getAnd);
+ return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getAnd);
case Instruction::Or:
- return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getOr);
+ return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getOr);
case Instruction::Xor:
- return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getXor);
+ return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getXor);
case Instruction::LShr:
- return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getLShr);
+ return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getLShr);
case Instruction::AShr:
- return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getAShr);
+ return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getAShr);
case Instruction::Shl:
- return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getShl);
+ return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getShl);
}
}
}
@@ -877,7 +892,7 @@
case Instruction::Or:
case Instruction::Xor:
// No change of opcode required.
- return ConstantFoldBinaryInstruction(Opcode, C2, C1);
+ return ConstantFoldBinaryInstruction(Context, Opcode, C2, C1);
case Instruction::Shl:
case Instruction::LShr:
@@ -923,7 +938,8 @@
/// first is less than the second, return -1, if the second is less than the
/// first, return 1. If the constants are not integral, return -2.
///
-static int IdxCompare(Constant *C1, Constant *C2, const Type *ElTy) {
+static int IdxCompare(LLVMContext &Context, Constant *C1, Constant *C2,
+ const Type *ElTy) {
if (C1 == C2) return 0;
// Ok, we found a different index. If they are not ConstantInt, we can't do
@@ -934,10 +950,10 @@
// Ok, we have two differing integer indices. Sign extend them to be the same
// type. Long is always big enough, so we use it.
if (C1->getType() != Type::Int64Ty)
- C1 = ConstantExpr::getSExt(C1, Type::Int64Ty);
+ C1 = Context.getConstantExprSExt(C1, Type::Int64Ty);
if (C2->getType() != Type::Int64Ty)
- C2 = ConstantExpr::getSExt(C2, Type::Int64Ty);
+ C2 = Context.getConstantExprSExt(C2, Type::Int64Ty);
if (C1 == C2) return 0; // They are equal
@@ -966,7 +982,8 @@
/// To simplify this code we canonicalize the relation so that the first
/// operand is always the most "complex" of the two. We consider ConstantFP
/// to be the simplest, and ConstantExprs to be the most complex.
-static FCmpInst::Predicate evaluateFCmpRelation(const Constant *V1,
+static FCmpInst::Predicate evaluateFCmpRelation(LLVMContext &Context,
+ const Constant *V1,
const Constant *V2) {
assert(V1->getType() == V2->getType() &&
"Cannot compare values of different types!");
@@ -985,15 +1002,15 @@
Constant *C1 = const_cast<Constant*>(V1);
Constant *C2 = const_cast<Constant*>(V2);
R = dyn_cast<ConstantInt>(
- ConstantExpr::getFCmp(FCmpInst::FCMP_OEQ, C1, C2));
+ Context.getConstantExprFCmp(FCmpInst::FCMP_OEQ, C1, C2));
if (R && !R->isZero())
return FCmpInst::FCMP_OEQ;
R = dyn_cast<ConstantInt>(
- ConstantExpr::getFCmp(FCmpInst::FCMP_OLT, C1, C2));
+ Context.getConstantExprFCmp(FCmpInst::FCMP_OLT, C1, C2));
if (R && !R->isZero())
return FCmpInst::FCMP_OLT;
R = dyn_cast<ConstantInt>(
- ConstantExpr::getFCmp(FCmpInst::FCMP_OGT, C1, C2));
+ Context.getConstantExprFCmp(FCmpInst::FCMP_OGT, C1, C2));
if (R && !R->isZero())
return FCmpInst::FCMP_OGT;
@@ -1002,7 +1019,7 @@
}
// If the first operand is simple and second is ConstantExpr, swap operands.
- FCmpInst::Predicate SwappedRelation = evaluateFCmpRelation(V2, V1);
+ FCmpInst::Predicate SwappedRelation = evaluateFCmpRelation(Context, V2, V1);
if (SwappedRelation != FCmpInst::BAD_FCMP_PREDICATE)
return FCmpInst::getSwappedPredicate(SwappedRelation);
} else {
@@ -1037,7 +1054,8 @@
/// constants (like ConstantInt) to be the simplest, followed by
/// GlobalValues, followed by ConstantExpr's (the most complex).
///
-static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1,
+static ICmpInst::Predicate evaluateICmpRelation(LLVMContext &Context,
+ const Constant *V1,
const Constant *V2,
bool isSigned) {
assert(V1->getType() == V2->getType() &&
@@ -1052,15 +1070,15 @@
Constant *C1 = const_cast<Constant*>(V1);
Constant *C2 = const_cast<Constant*>(V2);
ICmpInst::Predicate pred = ICmpInst::ICMP_EQ;
- R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2));
+ R = dyn_cast<ConstantInt>(Context.getConstantExprICmp(pred, C1, C2));
if (R && !R->isZero())
return pred;
pred = isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
- R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2));
+ R = dyn_cast<ConstantInt>(Context.getConstantExprICmp(pred, C1, C2));
if (R && !R->isZero())
return pred;
pred = isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
- R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2));
+ R = dyn_cast<ConstantInt>(Context.getConstantExprICmp(pred, C1, C2));
if (R && !R->isZero())
return pred;
@@ -1070,14 +1088,14 @@
// If the first operand is simple, swap operands.
ICmpInst::Predicate SwappedRelation =
- evaluateICmpRelation(V2, V1, isSigned);
+ evaluateICmpRelation(Context, V2, V1, isSigned);
if (SwappedRelation != ICmpInst::BAD_ICMP_PREDICATE)
return ICmpInst::getSwappedPredicate(SwappedRelation);
} else if (const GlobalValue *CPR1 = dyn_cast<GlobalValue>(V1)) {
if (isa<ConstantExpr>(V2)) { // Swap as necessary.
ICmpInst::Predicate SwappedRelation =
- evaluateICmpRelation(V2, V1, isSigned);
+ evaluateICmpRelation(Context, V2, V1, isSigned);
if (SwappedRelation != ICmpInst::BAD_ICMP_PREDICATE)
return ICmpInst::getSwappedPredicate(SwappedRelation);
else
@@ -1123,8 +1141,8 @@
bool sgnd = isSigned;
if (CE1->getOpcode() == Instruction::ZExt) isSigned = false;
if (CE1->getOpcode() == Instruction::SExt) isSigned = true;
- return evaluateICmpRelation(CE1Op0,
- Constant::getNullValue(CE1Op0->getType()),
+ return evaluateICmpRelation(Context, CE1Op0,
+ Context.getNullValue(CE1Op0->getType()),
sgnd);
}
@@ -1139,8 +1157,8 @@
bool sgnd = isSigned;
if (CE1->getOpcode() == Instruction::ZExt) isSigned = false;
if (CE1->getOpcode() == Instruction::SExt) isSigned = true;
- return evaluateICmpRelation(CE1->getOperand(0), CE2->getOperand(0),
- sgnd);
+ return evaluateICmpRelation(Context, CE1->getOperand(0),
+ CE2->getOperand(0), sgnd);
}
break;
@@ -1219,8 +1237,8 @@
gep_type_iterator GTI = gep_type_begin(CE1);
for (;i != CE1->getNumOperands() && i != CE2->getNumOperands();
++i, ++GTI)
- switch (IdxCompare(CE1->getOperand(i), CE2->getOperand(i),
- GTI.getIndexedType())) {
+ switch (IdxCompare(Context, CE1->getOperand(i),
+ CE2->getOperand(i), GTI.getIndexedType())) {
case -1: return isSigned ? ICmpInst::ICMP_SLT:ICmpInst::ICMP_ULT;
case 1: return isSigned ? ICmpInst::ICMP_SGT:ICmpInst::ICMP_UGT;
case -2: return ICmpInst::BAD_ICMP_PREDICATE;
@@ -1255,25 +1273,26 @@
return ICmpInst::BAD_ICMP_PREDICATE;
}
-Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred,
+Constant *llvm::ConstantFoldCompareInstruction(LLVMContext &Context,
+ unsigned short pred,
const Constant *C1,
const Constant *C2) {
const Type *ResultTy;
if (const VectorType *VT = dyn_cast<VectorType>(C1->getType()))
- ResultTy = VectorType::get(Type::Int1Ty, VT->getNumElements());
+ ResultTy = Context.getVectorType(Type::Int1Ty, VT->getNumElements());
else
ResultTy = Type::Int1Ty;
// Fold FCMP_FALSE/FCMP_TRUE unconditionally.
if (pred == FCmpInst::FCMP_FALSE)
- return Constant::getNullValue(ResultTy);
+ return Context.getNullValue(ResultTy);
if (pred == FCmpInst::FCMP_TRUE)
- return Constant::getAllOnesValue(ResultTy);
+ return Context.getAllOnesValue(ResultTy);
// Handle some degenerate cases first
if (isa<UndefValue>(C1) || isa<UndefValue>(C2))
- return UndefValue::get(ResultTy);
+ return Context.getUndef(ResultTy);
// No compile-time operations on this type yet.
if (C1->getType() == Type::PPC_FP128Ty)
@@ -1285,9 +1304,9 @@
// Don't try to evaluate aliases. External weak GV can be null.
if (!isa<GlobalAlias>(GV) && !GV->hasExternalWeakLinkage()) {
if (pred == ICmpInst::ICMP_EQ)
- return ConstantInt::getFalse();
+ return Context.getConstantIntFalse();
else if (pred == ICmpInst::ICMP_NE)
- return ConstantInt::getTrue();
+ return Context.getConstantIntTrue();
}
// icmp eq/ne(GV,null) -> false/true
} else if (C2->isNullValue()) {
@@ -1295,9 +1314,9 @@
// Don't try to evaluate aliases. External weak GV can be null.
if (!isa<GlobalAlias>(GV) && !GV->hasExternalWeakLinkage()) {
if (pred == ICmpInst::ICMP_EQ)
- return ConstantInt::getFalse();
+ return Context.getConstantIntFalse();
else if (pred == ICmpInst::ICMP_NE)
- return ConstantInt::getTrue();
+ return Context.getConstantIntTrue();
}
}
@@ -1306,16 +1325,26 @@
APInt V2 = cast<ConstantInt>(C2)->getValue();
switch (pred) {
default: LLVM_UNREACHABLE("Invalid ICmp Predicate"); return 0;
- case ICmpInst::ICMP_EQ: return ConstantInt::get(Type::Int1Ty, V1 == V2);
- case ICmpInst::ICMP_NE: return ConstantInt::get(Type::Int1Ty, V1 != V2);
- case ICmpInst::ICMP_SLT:return ConstantInt::get(Type::Int1Ty, V1.slt(V2));
- case ICmpInst::ICMP_SGT:return ConstantInt::get(Type::Int1Ty, V1.sgt(V2));
- case ICmpInst::ICMP_SLE:return ConstantInt::get(Type::Int1Ty, V1.sle(V2));
- case ICmpInst::ICMP_SGE:return ConstantInt::get(Type::Int1Ty, V1.sge(V2));
- case ICmpInst::ICMP_ULT:return ConstantInt::get(Type::Int1Ty, V1.ult(V2));
- case ICmpInst::ICMP_UGT:return ConstantInt::get(Type::Int1Ty, V1.ugt(V2));
- case ICmpInst::ICMP_ULE:return ConstantInt::get(Type::Int1Ty, V1.ule(V2));
- case ICmpInst::ICMP_UGE:return ConstantInt::get(Type::Int1Ty, V1.uge(V2));
+ case ICmpInst::ICMP_EQ:
+ return Context.getConstantInt(Type::Int1Ty, V1 == V2);
+ case ICmpInst::ICMP_NE:
+ return Context.getConstantInt(Type::Int1Ty, V1 != V2);
+ case ICmpInst::ICMP_SLT:
+ return Context.getConstantInt(Type::Int1Ty, V1.slt(V2));
+ case ICmpInst::ICMP_SGT:
+ return Context.getConstantInt(Type::Int1Ty, V1.sgt(V2));
+ case ICmpInst::ICMP_SLE:
+ return Context.getConstantInt(Type::Int1Ty, V1.sle(V2));
+ case ICmpInst::ICMP_SGE:
+ return Context.getConstantInt(Type::Int1Ty, V1.sge(V2));
+ case ICmpInst::ICMP_ULT:
+ return Context.getConstantInt(Type::Int1Ty, V1.ult(V2));
+ case ICmpInst::ICMP_UGT:
+ return Context.getConstantInt(Type::Int1Ty, V1.ugt(V2));
+ case ICmpInst::ICMP_ULE:
+ return Context.getConstantInt(Type::Int1Ty, V1.ule(V2));
+ case ICmpInst::ICMP_UGE:
+ return Context.getConstantInt(Type::Int1Ty, V1.uge(V2));
}
} else if (isa<ConstantFP>(C1) && isa<ConstantFP>(C2)) {
APFloat C1V = cast<ConstantFP>(C1)->getValueAPF();
@@ -1323,61 +1352,62 @@
APFloat::cmpResult R = C1V.compare(C2V);
switch (pred) {
default: LLVM_UNREACHABLE("Invalid FCmp Predicate"); return 0;
- case FCmpInst::FCMP_FALSE: return ConstantInt::getFalse();
- case FCmpInst::FCMP_TRUE: return ConstantInt::getTrue();
+ case FCmpInst::FCMP_FALSE: return Context.getConstantIntFalse();
+ case FCmpInst::FCMP_TRUE: return Context.getConstantIntTrue();
case FCmpInst::FCMP_UNO:
- return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered);
+ return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpUnordered);
case FCmpInst::FCMP_ORD:
- return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpUnordered);
+ return Context.getConstantInt(Type::Int1Ty, R!=APFloat::cmpUnordered);
case FCmpInst::FCMP_UEQ:
- return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered ||
+ return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpUnordered ||
R==APFloat::cmpEqual);
case FCmpInst::FCMP_OEQ:
- return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpEqual);
+ return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpEqual);
case FCmpInst::FCMP_UNE:
- return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpEqual);
+ return Context.getConstantInt(Type::Int1Ty, R!=APFloat::cmpEqual);
case FCmpInst::FCMP_ONE:
- return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan ||
+ return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpLessThan ||
R==APFloat::cmpGreaterThan);
case FCmpInst::FCMP_ULT:
- return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered ||
+ return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpUnordered ||
R==APFloat::cmpLessThan);
case FCmpInst::FCMP_OLT:
- return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan);
+ return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpLessThan);
case FCmpInst::FCMP_UGT:
- return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered ||
+ return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpUnordered ||
R==APFloat::cmpGreaterThan);
case FCmpInst::FCMP_OGT:
- return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpGreaterThan);
+ return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpGreaterThan);
case FCmpInst::FCMP_ULE:
- return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpGreaterThan);
+ return Context.getConstantInt(Type::Int1Ty, R!=APFloat::cmpGreaterThan);
case FCmpInst::FCMP_OLE:
- return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan ||
+ return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpLessThan ||
R==APFloat::cmpEqual);
case FCmpInst::FCMP_UGE:
- return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpLessThan);
+ return Context.getConstantInt(Type::Int1Ty, R!=APFloat::cmpLessThan);
case FCmpInst::FCMP_OGE:
- return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpGreaterThan ||
+ return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpGreaterThan ||
R==APFloat::cmpEqual);
}
} else if (isa<VectorType>(C1->getType())) {
SmallVector<Constant*, 16> C1Elts, C2Elts;
- C1->getVectorElements(C1Elts);
- C2->getVectorElements(C2Elts);
+ C1->getVectorElements(Context, C1Elts);
+ C2->getVectorElements(Context, C2Elts);
// If we can constant fold the comparison of each element, constant fold
// the whole vector comparison.
SmallVector<Constant*, 4> ResElts;
for (unsigned i = 0, e = C1Elts.size(); i != e; ++i) {
// Compare the elements, producing an i1 result or constant expr.
- ResElts.push_back(ConstantExpr::getCompare(pred, C1Elts[i], C2Elts[i]));
+ ResElts.push_back(
+ Context.getConstantExprCompare(pred, C1Elts[i], C2Elts[i]));
}
- return ConstantVector::get(&ResElts[0], ResElts.size());
+ return Context.getConstantVector(&ResElts[0], ResElts.size());
}
if (C1->getType()->isFloatingPoint()) {
int Result = -1; // -1 = unknown, 0 = known false, 1 = known true.
- switch (evaluateFCmpRelation(C1, C2)) {
+ switch (evaluateFCmpRelation(Context, C1, C2)) {
default: LLVM_UNREACHABLE("Unknown relation!");
case FCmpInst::FCMP_UNO:
case FCmpInst::FCMP_ORD:
@@ -1431,12 +1461,12 @@
// If we evaluated the result, return it now.
if (Result != -1)
- return ConstantInt::get(Type::Int1Ty, Result);
+ return Context.getConstantInt(Type::Int1Ty, Result);
} else {
// Evaluate the relation between the two constants, per the predicate.
int Result = -1; // -1 = unknown, 0 = known false, 1 = known true.
- switch (evaluateICmpRelation(C1, C2, CmpInst::isSigned(pred))) {
+ switch (evaluateICmpRelation(Context, C1, C2, CmpInst::isSigned(pred))) {
default: LLVM_UNREACHABLE("Unknown relational!");
case ICmpInst::BAD_ICMP_PREDICATE:
break; // Couldn't determine anything about these constants.
@@ -1508,7 +1538,7 @@
// If we evaluated the result, return it now.
if (Result != -1)
- return ConstantInt::get(Type::Int1Ty, Result);
+ return Context.getConstantInt(Type::Int1Ty, Result);
if (!isa<ConstantExpr>(C1) && isa<ConstantExpr>(C2)) {
// If C2 is a constant expr and C1 isn't, flip them around and fold the
@@ -1517,7 +1547,7 @@
case ICmpInst::ICMP_EQ:
case ICmpInst::ICMP_NE:
// No change of predicate required.
- return ConstantFoldCompareInstruction(pred, C2, C1);
+ return ConstantFoldCompareInstruction(Context, pred, C2, C1);
case ICmpInst::ICMP_ULT:
case ICmpInst::ICMP_SLT:
@@ -1529,7 +1559,7 @@
case ICmpInst::ICMP_SGE:
// Change the predicate as necessary to swap the operands.
pred = ICmpInst::getSwappedPredicate((ICmpInst::Predicate)pred);
- return ConstantFoldCompareInstruction(pred, C2, C1);
+ return ConstantFoldCompareInstruction(Context, pred, C2, C1);
default: // These predicates cannot be flopped around.
break;
@@ -1539,7 +1569,8 @@
return 0;
}
-Constant *llvm::ConstantFoldGetElementPtr(const Constant *C,
+Constant *llvm::ConstantFoldGetElementPtr(LLVMContext &Context,
+ const Constant *C,
Constant* const *Idxs,
unsigned NumIdx) {
if (NumIdx == 0 ||
@@ -1552,7 +1583,7 @@
(Value **)Idxs,
(Value **)Idxs+NumIdx);
assert(Ty != 0 && "Invalid indices for GEP!");
- return UndefValue::get(PointerType::get(Ty, Ptr->getAddressSpace()));
+ return Context.getUndef(Context.getPointerType(Ty, Ptr->getAddressSpace()));
}
Constant *Idx0 = Idxs[0];
@@ -1569,8 +1600,8 @@
(Value**)Idxs,
(Value**)Idxs+NumIdx);
assert(Ty != 0 && "Invalid indices for GEP!");
- return
- ConstantPointerNull::get(PointerType::get(Ty,Ptr->getAddressSpace()));
+ return Context.getConstantPointerNull(
+ Context.getPointerType(Ty,Ptr->getAddressSpace()));
}
}
@@ -1598,19 +1629,21 @@
if (!Idx0->isNullValue()) {
const Type *IdxTy = Combined->getType();
if (IdxTy != Idx0->getType()) {
- Constant *C1 = ConstantExpr::getSExtOrBitCast(Idx0, Type::Int64Ty);
- Constant *C2 = ConstantExpr::getSExtOrBitCast(Combined,
+ Constant *C1 =
+ Context.getConstantExprSExtOrBitCast(Idx0, Type::Int64Ty);
+ Constant *C2 = Context.getConstantExprSExtOrBitCast(Combined,
Type::Int64Ty);
- Combined = ConstantExpr::get(Instruction::Add, C1, C2);
+ Combined = Context.getConstantExpr(Instruction::Add, C1, C2);
} else {
Combined =
- ConstantExpr::get(Instruction::Add, Idx0, Combined);
+ Context.getConstantExpr(Instruction::Add, Idx0, Combined);
}
}
NewIndices.push_back(Combined);
NewIndices.insert(NewIndices.end(), Idxs+1, Idxs+NumIdx);
- return ConstantExpr::getGetElementPtr(CE->getOperand(0), &NewIndices[0],
+ return Context.getConstantExprGetElementPtr(CE->getOperand(0),
+ &NewIndices[0],
NewIndices.size());
}
}
@@ -1627,7 +1660,7 @@
if (const ArrayType *CAT =
dyn_cast<ArrayType>(cast<PointerType>(C->getType())->getElementType()))
if (CAT->getElementType() == SAT->getElementType())
- return ConstantExpr::getGetElementPtr(
+ return Context.getConstantExprGetElementPtr(
(Constant*)CE->getOperand(0), Idxs, NumIdx);
}
@@ -1643,13 +1676,13 @@
// Convert the smaller integer to the larger type.
if (Offset->getType()->getPrimitiveSizeInBits() <
Base->getType()->getPrimitiveSizeInBits())
- Offset = ConstantExpr::getSExt(Offset, Base->getType());
+ Offset = Context.getConstantExprSExt(Offset, Base->getType());
else if (Base->getType()->getPrimitiveSizeInBits() <
Offset->getType()->getPrimitiveSizeInBits())
- Base = ConstantExpr::getZExt(Base, Offset->getType());
+ Base = Context.getConstantExprZExt(Base, Offset->getType());
- Base = ConstantExpr::getAdd(Base, Offset);
- return ConstantExpr::getIntToPtr(Base, CE->getType());
+ Base = Context.getConstantExprAdd(Base, Offset);
+ return Context.getConstantExprIntToPtr(Base, CE->getType());
}
}
return 0;
Modified: llvm/trunk/lib/VMCore/ConstantFold.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/VMCore/ConstantFold.h?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/VMCore/ConstantFold.h (original)
+++ llvm/trunk/lib/VMCore/ConstantFold.h Sun Jul 12 23:09:18 2009
@@ -23,37 +23,47 @@
class Value;
class Constant;
class Type;
+ class LLVMContext;
// Constant fold various types of instruction...
Constant *ConstantFoldCastInstruction(
+ LLVMContext &Context,
unsigned opcode, ///< The opcode of the cast
const Constant *V, ///< The source constant
const Type *DestTy ///< The destination type
);
- Constant *ConstantFoldSelectInstruction(const Constant *Cond,
+ Constant *ConstantFoldSelectInstruction(LLVMContext &Context,
+ const Constant *Cond,
const Constant *V1,
const Constant *V2);
- Constant *ConstantFoldExtractElementInstruction(const Constant *Val,
+ Constant *ConstantFoldExtractElementInstruction(LLVMContext &Context,
+ const Constant *Val,
const Constant *Idx);
- Constant *ConstantFoldInsertElementInstruction(const Constant *Val,
+ Constant *ConstantFoldInsertElementInstruction(LLVMContext &Context,
+ const Constant *Val,
const Constant *Elt,
const Constant *Idx);
- Constant *ConstantFoldShuffleVectorInstruction(const Constant *V1,
+ Constant *ConstantFoldShuffleVectorInstruction(LLVMContext &Context,
+ const Constant *V1,
const Constant *V2,
const Constant *Mask);
- Constant *ConstantFoldExtractValueInstruction(const Constant *Agg,
+ Constant *ConstantFoldExtractValueInstruction(LLVMContext &Context,
+ const Constant *Agg,
const unsigned *Idxs,
unsigned NumIdx);
- Constant *ConstantFoldInsertValueInstruction(const Constant *Agg,
+ Constant *ConstantFoldInsertValueInstruction(LLVMContext &Context,
+ const Constant *Agg,
const Constant *Val,
const unsigned* Idxs,
unsigned NumIdx);
- Constant *ConstantFoldBinaryInstruction(unsigned Opcode, const Constant *V1,
+ Constant *ConstantFoldBinaryInstruction(LLVMContext &Context,
+ unsigned Opcode, const Constant *V1,
const Constant *V2);
- Constant *ConstantFoldCompareInstruction(unsigned short predicate,
+ Constant *ConstantFoldCompareInstruction(LLVMContext &Context,
+ unsigned short predicate,
const Constant *C1,
const Constant *C2);
- Constant *ConstantFoldGetElementPtr(const Constant *C,
+ Constant *ConstantFoldGetElementPtr(LLVMContext &Context, const Constant *C,
Constant* const *Idxs, unsigned NumIdx);
} // End llvm namespace
Modified: llvm/trunk/lib/VMCore/Constants.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/VMCore/Constants.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/VMCore/Constants.cpp (original)
+++ llvm/trunk/lib/VMCore/Constants.cpp Sun Jul 12 23:09:18 2009
@@ -128,35 +128,6 @@
return false;
}
-// Static constructor to create a '0' constant of arbitrary type...
-static const uint64_t zero[2] = {0, 0};
-Constant *Constant::getNullValue(const Type *Ty) {
- switch (Ty->getTypeID()) {
- case Type::IntegerTyID:
- return ConstantInt::get(Ty, 0);
- case Type::FloatTyID:
- return ConstantFP::get(APFloat(APInt(32, 0)));
- case Type::DoubleTyID:
- return ConstantFP::get(APFloat(APInt(64, 0)));
- case Type::X86_FP80TyID:
- return ConstantFP::get(APFloat(APInt(80, 2, zero)));
- case Type::FP128TyID:
- return ConstantFP::get(APFloat(APInt(128, 2, zero), true));
- case Type::PPC_FP128TyID:
- return ConstantFP::get(APFloat(APInt(128, 2, zero)));
- case Type::PointerTyID:
- return ConstantPointerNull::get(cast<PointerType>(Ty));
- case Type::StructTyID:
- case Type::ArrayTyID:
- case Type::VectorTyID:
- return ConstantAggregateZero::get(Ty);
- default:
- // Function, Label, or Opaque type?
- assert(!"Cannot create a null constant of that type!");
- return 0;
- }
-}
-
Constant *Constant::getAllOnesValue(const Type *Ty) {
if (const IntegerType* ITy = dyn_cast<IntegerType>(Ty))
return ConstantInt::get(APInt::getAllOnesValue(ITy->getBitWidth()));
@@ -186,7 +157,8 @@
/// type, returns the elements of the vector in the specified smallvector.
/// This handles breaking down a vector undef into undef elements, etc. For
/// constant exprs and other cases we can't handle, we return an empty vector.
-void Constant::getVectorElements(SmallVectorImpl<Constant*> &Elts) const {
+void Constant::getVectorElements(LLVMContext &Context,
+ SmallVectorImpl<Constant*> &Elts) const {
assert(isa<VectorType>(getType()) && "Not a vector constant!");
if (const ConstantVector *CV = dyn_cast<ConstantVector>(this)) {
@@ -198,12 +170,12 @@
const VectorType *VT = cast<VectorType>(getType());
if (isa<ConstantAggregateZero>(this)) {
Elts.assign(VT->getNumElements(),
- Constant::getNullValue(VT->getElementType()));
+ Context.getNullValue(VT->getElementType()));
return;
}
if (isa<UndefValue>(this)) {
- Elts.assign(VT->getNumElements(), UndefValue::get(VT->getElementType()));
+ Elts.assign(VT->getNumElements(), Context.getUndef(VT->getElementType()));
return;
}
@@ -361,12 +333,6 @@
return Val.isZero() && !Val.isNegative();
}
-ConstantFP *ConstantFP::getNegativeZero(const Type *Ty) {
- APFloat apf = cast <ConstantFP>(Constant::getNullValue(Ty))->getValueAPF();
- apf.changeSign();
- return ConstantFP::get(apf);
-}
-
bool ConstantFP::isExactlyValue(const APFloat& V) const {
return Val.bitwiseIsEqual(V);
}
@@ -831,26 +797,6 @@
return cast<InsertValueConstantExpr>(this)->Indices;
}
-/// ConstantExpr::get* - Return some common constants without having to
-/// specify the full Instruction::OPCODE identifier.
-///
-Constant *ConstantExpr::getNeg(Constant *C) {
- // API compatibility: Adjust integer opcodes to floating-point opcodes.
- if (C->getType()->isFPOrFPVector())
- return getFNeg(C);
- assert(C->getType()->isIntOrIntVector() &&
- "Cannot NEG a nonintegral value!");
- return get(Instruction::Sub,
- ConstantExpr::getZeroValueForNegationExpr(C->getType()),
- C);
-}
-Constant *ConstantExpr::getFNeg(Constant *C) {
- assert(C->getType()->isFPOrFPVector() &&
- "Cannot FNEG a non-floating-point value!");
- return get(Instruction::FSub,
- ConstantExpr::getZeroValueForNegationExpr(C->getType()),
- C);
-}
Constant *ConstantExpr::getNot(Constant *C) {
assert(C->getType()->isIntOrIntVector() &&
"Cannot NOT a nonintegral value!");
@@ -1501,11 +1447,11 @@
/// isCString - This method returns true if the array is a string (see
/// isString) and it ends in a null byte \\0 and does not contains any other
/// null bytes except its terminator.
-bool ConstantArray::isCString() const {
+bool ConstantArray::isCString(LLVMContext &Context) const {
// Check the element type for i8...
if (getType()->getElementType() != Type::Int8Ty)
return false;
- Constant *Zero = Constant::getNullValue(getOperand(0)->getType());
+ Constant *Zero = Context.getNullValue(getOperand(0)->getType());
// Last element must be a null.
if (getOperand(getNumOperands()-1) != Zero)
return false;
@@ -2011,7 +1957,8 @@
Instruction::CastOps opc, Constant *C, const Type *Ty) {
assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!");
// Fold a few common cases
- if (Constant *FC = ConstantFoldCastInstruction(opc, C, Ty))
+ if (Constant *FC =
+ ConstantFoldCastInstruction(getGlobalContext(), opc, C, Ty))
return FC;
// Look up the constant in the table first to ensure uniqueness
@@ -2245,25 +2192,6 @@
return getFoldedCast(Instruction::BitCast, C, DstTy);
}
-Constant *ConstantExpr::getAlignOf(const Type *Ty) {
- // alignof is implemented as: (i64) gep ({i8,Ty}*)null, 0, 1
- const Type *AligningTy = StructType::get(Type::Int8Ty, Ty, NULL);
- Constant *NullPtr = getNullValue(AligningTy->getPointerTo());
- Constant *Zero = ConstantInt::get(Type::Int32Ty, 0);
- Constant *One = ConstantInt::get(Type::Int32Ty, 1);
- Constant *Indices[2] = { Zero, One };
- Constant *GEP = getGetElementPtr(NullPtr, Indices, 2);
- return getCast(Instruction::PtrToInt, GEP, Type::Int32Ty);
-}
-
-Constant *ConstantExpr::getSizeOf(const Type *Ty) {
- // sizeof is implemented as: (i64) gep (Ty*)null, 1
- Constant *GEPIdx = ConstantInt::get(Type::Int32Ty, 1);
- Constant *GEP =
- getGetElementPtr(getNullValue(PointerType::getUnqual(Ty)), &GEPIdx, 1);
- return getCast(Instruction::PtrToInt, GEP, Type::Int64Ty);
-}
-
Constant *ConstantExpr::getTy(const Type *ReqTy, unsigned Opcode,
Constant *C1, Constant *C2) {
// Check the operands for consistency first
@@ -2274,7 +2202,8 @@
"Operand types in binary constant expression should match");
if (ReqTy == C1->getType() || ReqTy == Type::Int1Ty)
- if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2))
+ if (Constant *FC = ConstantFoldBinaryInstruction(
+ getGlobalContext(), Opcode, C1, C2))
return FC; // Fold a few common cases...
std::vector<Constant*> argVec(1, C1); argVec.push_back(C2);
@@ -2383,7 +2312,8 @@
assert(!SelectInst::areInvalidOperands(C, V1, V2)&&"Invalid select operands");
if (ReqTy == V1->getType())
- if (Constant *SC = ConstantFoldSelectInstruction(C, V1, V2))
+ if (Constant *SC = ConstantFoldSelectInstruction(
+ getGlobalContext(), C, V1, V2))
return SC; // Fold common cases
std::vector<Constant*> argVec(3, C);
@@ -2403,7 +2333,8 @@
cast<PointerType>(ReqTy)->getElementType() &&
"GEP indices invalid!");
- if (Constant *FC = ConstantFoldGetElementPtr(C, (Constant**)Idxs, NumIdx))
+ if (Constant *FC = ConstantFoldGetElementPtr(
+ getGlobalContext(), C, (Constant**)Idxs, NumIdx))
return FC; // Fold a few common cases...
assert(isa<PointerType>(C->getType()) &&
@@ -2442,7 +2373,8 @@
assert(pred >= ICmpInst::FIRST_ICMP_PREDICATE &&
pred <= ICmpInst::LAST_ICMP_PREDICATE && "Invalid ICmp Predicate");
- if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
+ if (Constant *FC = ConstantFoldCompareInstruction(
+ getGlobalContext(),pred, LHS, RHS))
return FC; // Fold a few common cases...
// Look up the constant in the table first to ensure uniqueness
@@ -2461,7 +2393,8 @@
assert(LHS->getType() == RHS->getType());
assert(pred <= FCmpInst::LAST_FCMP_PREDICATE && "Invalid FCmp Predicate");
- if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
+ if (Constant *FC = ConstantFoldCompareInstruction(
+ getGlobalContext(), pred, LHS, RHS))
return FC; // Fold a few common cases...
// Look up the constant in the table first to ensure uniqueness
@@ -2477,7 +2410,8 @@
Constant *ConstantExpr::getExtractElementTy(const Type *ReqTy, Constant *Val,
Constant *Idx) {
- if (Constant *FC = ConstantFoldExtractElementInstruction(Val, Idx))
+ if (Constant *FC = ConstantFoldExtractElementInstruction(
+ getGlobalContext(), Val, Idx))
return FC; // Fold a few common cases...
// Look up the constant in the table first to ensure uniqueness
std::vector<Constant*> ArgVec(1, Val);
@@ -2499,7 +2433,8 @@
Constant *ConstantExpr::getInsertElementTy(const Type *ReqTy, Constant *Val,
Constant *Elt, Constant *Idx) {
- if (Constant *FC = ConstantFoldInsertElementInstruction(Val, Elt, Idx))
+ if (Constant *FC = ConstantFoldInsertElementInstruction(
+ getGlobalContext(), Val, Elt, Idx))
return FC; // Fold a few common cases...
// Look up the constant in the table first to ensure uniqueness
std::vector<Constant*> ArgVec(1, Val);
@@ -2524,7 +2459,8 @@
Constant *ConstantExpr::getShuffleVectorTy(const Type *ReqTy, Constant *V1,
Constant *V2, Constant *Mask) {
- if (Constant *FC = ConstantFoldShuffleVectorInstruction(V1, V2, Mask))
+ if (Constant *FC = ConstantFoldShuffleVectorInstruction(
+ getGlobalContext(), V1, V2, Mask))
return FC; // Fold a few common cases...
// Look up the constant in the table first to ensure uniqueness
std::vector<Constant*> ArgVec(1, V1);
@@ -2557,7 +2493,8 @@
"insertvalue type invalid!");
assert(Agg->getType()->isFirstClassType() &&
"Non-first-class type for constant InsertValue expression");
- Constant *FC = ConstantFoldInsertValueInstruction(Agg, Val, Idxs, NumIdx);
+ Constant *FC = ConstantFoldInsertValueInstruction(
+ getGlobalContext(), Agg, Val, Idxs, NumIdx);
assert(FC && "InsertValue constant expr couldn't be folded!");
return FC;
}
@@ -2583,7 +2520,8 @@
"extractvalue indices invalid!");
assert(Agg->getType()->isFirstClassType() &&
"Non-first-class type for constant extractvalue expression");
- Constant *FC = ConstantFoldExtractValueInstruction(Agg, Idxs, NumIdx);
+ Constant *FC = ConstantFoldExtractValueInstruction(
+ getGlobalContext(), Agg, Idxs, NumIdx);
assert(FC && "ExtractValue constant expr couldn't be folded!");
return FC;
}
@@ -2599,20 +2537,6 @@
return getExtractValueTy(ReqTy, Agg, IdxList, NumIdx);
}
-Constant *ConstantExpr::getZeroValueForNegationExpr(const Type *Ty) {
- if (const VectorType *PTy = dyn_cast<VectorType>(Ty))
- if (PTy->getElementType()->isFloatingPoint()) {
- std::vector<Constant*> zeros(PTy->getNumElements(),
- ConstantFP::getNegativeZero(PTy->getElementType()));
- return ConstantVector::get(PTy, zeros);
- }
-
- if (Ty->isFloatingPoint())
- return ConstantFP::getNegativeZero(Ty);
-
- return Constant::getNullValue(Ty);
-}
-
// destroyConstant - Remove the constant from the constant table...
//
void ConstantExpr::destroyConstant() {
Modified: llvm/trunk/lib/VMCore/Instructions.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/VMCore/Instructions.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/VMCore/Instructions.cpp (original)
+++ llvm/trunk/lib/VMCore/Instructions.cpp Sun Jul 12 23:09:18 2009
@@ -1633,33 +1633,37 @@
return Res;
}
-BinaryOperator *BinaryOperator::CreateNeg(Value *Op, const std::string &Name,
+BinaryOperator *BinaryOperator::CreateNeg(LLVMContext &Context,
+ Value *Op, const std::string &Name,
Instruction *InsertBefore) {
- Value *zero = ConstantExpr::getZeroValueForNegationExpr(Op->getType());
+ Value *zero = Context.getZeroValueForNegation(Op->getType());
return new BinaryOperator(Instruction::Sub,
zero, Op,
Op->getType(), Name, InsertBefore);
}
-BinaryOperator *BinaryOperator::CreateNeg(Value *Op, const std::string &Name,
+BinaryOperator *BinaryOperator::CreateNeg(LLVMContext &Context,
+ Value *Op, const std::string &Name,
BasicBlock *InsertAtEnd) {
- Value *zero = ConstantExpr::getZeroValueForNegationExpr(Op->getType());
+ Value *zero = Context.getZeroValueForNegation(Op->getType());
return new BinaryOperator(Instruction::Sub,
zero, Op,
Op->getType(), Name, InsertAtEnd);
}
-BinaryOperator *BinaryOperator::CreateFNeg(Value *Op, const std::string &Name,
+BinaryOperator *BinaryOperator::CreateFNeg(LLVMContext &Context,
+ Value *Op, const std::string &Name,
Instruction *InsertBefore) {
- Value *zero = ConstantExpr::getZeroValueForNegationExpr(Op->getType());
+ Value *zero = Context.getZeroValueForNegation(Op->getType());
return new BinaryOperator(Instruction::FSub,
zero, Op,
Op->getType(), Name, InsertBefore);
}
-BinaryOperator *BinaryOperator::CreateFNeg(Value *Op, const std::string &Name,
+BinaryOperator *BinaryOperator::CreateFNeg(LLVMContext &Context,
+ Value *Op, const std::string &Name,
BasicBlock *InsertAtEnd) {
- Value *zero = ConstantExpr::getZeroValueForNegationExpr(Op->getType());
+ Value *zero = Context.getZeroValueForNegation(Op->getType());
return new BinaryOperator(Instruction::FSub,
zero, Op,
Op->getType(), Name, InsertAtEnd);
@@ -1705,19 +1709,19 @@
return false;
}
-bool BinaryOperator::isNeg(const Value *V) {
+bool BinaryOperator::isNeg(LLVMContext &Context, const Value *V) {
if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(V))
if (Bop->getOpcode() == Instruction::Sub)
return Bop->getOperand(0) ==
- ConstantExpr::getZeroValueForNegationExpr(Bop->getType());
+ Context.getZeroValueForNegation(Bop->getType());
return false;
}
-bool BinaryOperator::isFNeg(const Value *V) {
+bool BinaryOperator::isFNeg(LLVMContext &Context, const Value *V) {
if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(V))
if (Bop->getOpcode() == Instruction::FSub)
return Bop->getOperand(0) ==
- ConstantExpr::getZeroValueForNegationExpr(Bop->getType());
+ Context.getZeroValueForNegation(Bop->getType());
return false;
}
@@ -1730,7 +1734,6 @@
}
Value *BinaryOperator::getNegArgument(Value *BinOp) {
- assert(isNeg(BinOp) && "getNegArgument from non-'neg' instruction!");
return cast<BinaryOperator>(BinOp)->getOperand(1);
}
@@ -1739,7 +1742,6 @@
}
Value *BinaryOperator::getFNegArgument(Value *BinOp) {
- assert(isFNeg(BinOp) && "getFNegArgument from non-'fneg' instruction!");
return cast<BinaryOperator>(BinOp)->getOperand(1);
}
Modified: llvm/trunk/lib/VMCore/LLVMContext.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/VMCore/LLVMContext.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/lib/VMCore/LLVMContext.cpp (original)
+++ llvm/trunk/lib/VMCore/LLVMContext.cpp Sun Jul 12 23:09:18 2009
@@ -15,6 +15,7 @@
#include "llvm/LLVMContext.h"
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
+#include "llvm/Instruction.h"
#include "llvm/MDNode.h"
#include "llvm/Support/ManagedStatic.h"
#include "LLVMContextImpl.h"
@@ -31,8 +32,34 @@
LLVMContext::~LLVMContext() { delete pImpl; }
// Constant accessors
+
+// Constructor to create a '0' constant of arbitrary type...
+static const uint64_t zero[2] = {0, 0};
Constant* LLVMContext::getNullValue(const Type* Ty) {
- return Constant::getNullValue(Ty);
+ switch (Ty->getTypeID()) {
+ case Type::IntegerTyID:
+ return getConstantInt(Ty, 0);
+ case Type::FloatTyID:
+ return getConstantFP(APFloat(APInt(32, 0)));
+ case Type::DoubleTyID:
+ return getConstantFP(APFloat(APInt(64, 0)));
+ case Type::X86_FP80TyID:
+ return getConstantFP(APFloat(APInt(80, 2, zero)));
+ case Type::FP128TyID:
+ return getConstantFP(APFloat(APInt(128, 2, zero), true));
+ case Type::PPC_FP128TyID:
+ return getConstantFP(APFloat(APInt(128, 2, zero)));
+ case Type::PointerTyID:
+ return getConstantPointerNull(cast<PointerType>(Ty));
+ case Type::StructTyID:
+ case Type::ArrayTyID:
+ case Type::VectorTyID:
+ return getConstantAggregateZero(Ty);
+ default:
+ // Function, Label, or Opaque type?
+ assert(!"Cannot create a null constant of that type!");
+ return 0;
+ }
}
Constant* LLVMContext::getAllOnesValue(const Type* Ty) {
@@ -222,7 +249,14 @@
}
Constant* LLVMContext::getConstantExprAlignOf(const Type* Ty) {
- return ConstantExpr::getAlignOf(Ty);
+ // alignof is implemented as: (i64) gep ({i8,Ty}*)null, 0, 1
+ const Type *AligningTy = getStructType(Type::Int8Ty, Ty, NULL);
+ Constant *NullPtr = getNullValue(AligningTy->getPointerTo());
+ Constant *Zero = getConstantInt(Type::Int32Ty, 0);
+ Constant *One = getConstantInt(Type::Int32Ty, 1);
+ Constant *Indices[2] = { Zero, One };
+ Constant *GEP = getConstantExprGetElementPtr(NullPtr, Indices, 2);
+ return getConstantExprCast(Instruction::PtrToInt, GEP, Type::Int32Ty);
}
Constant* LLVMContext::getConstantExprCompare(unsigned short pred,
@@ -231,11 +265,22 @@
}
Constant* LLVMContext::getConstantExprNeg(Constant* C) {
- return ConstantExpr::getNeg(C);
+ // API compatibility: Adjust integer opcodes to floating-point opcodes.
+ if (C->getType()->isFPOrFPVector())
+ return getConstantExprFNeg(C);
+ assert(C->getType()->isIntOrIntVector() &&
+ "Cannot NEG a nonintegral value!");
+ return getConstantExpr(Instruction::Sub,
+ getZeroValueForNegation(C->getType()),
+ C);
}
Constant* LLVMContext::getConstantExprFNeg(Constant* C) {
- return ConstantExpr::getFNeg(C);
+ assert(C->getType()->isFPOrFPVector() &&
+ "Cannot FNEG a non-floating-point value!");
+ return getConstantExpr(Instruction::FSub,
+ getZeroValueForNegation(C->getType()),
+ C);
}
Constant* LLVMContext::getConstantExprNot(Constant* C) {
@@ -365,11 +410,25 @@
}
Constant* LLVMContext::getConstantExprSizeOf(const Type* Ty) {
- return ConstantExpr::getSizeOf(Ty);
+ // sizeof is implemented as: (i64) gep (Ty*)null, 1
+ Constant *GEPIdx = getConstantInt(Type::Int32Ty, 1);
+ Constant *GEP = getConstantExprGetElementPtr(
+ getNullValue(getPointerTypeUnqual(Ty)), &GEPIdx, 1);
+ return getConstantExprCast(Instruction::PtrToInt, GEP, Type::Int64Ty);
}
Constant* LLVMContext::getZeroValueForNegation(const Type* Ty) {
- return ConstantExpr::getZeroValueForNegationExpr(Ty);
+ if (const VectorType *PTy = dyn_cast<VectorType>(Ty))
+ if (PTy->getElementType()->isFloatingPoint()) {
+ std::vector<Constant*> zeros(PTy->getNumElements(),
+ getConstantFPNegativeZero(PTy->getElementType()));
+ return getConstantVector(PTy, zeros);
+ }
+
+ if (Ty->isFloatingPoint())
+ return getConstantFPNegativeZero(Ty);
+
+ return getNullValue(Ty);
}
@@ -383,7 +442,9 @@
}
ConstantFP* LLVMContext::getConstantFPNegativeZero(const Type* Ty) {
- return ConstantFP::getNegativeZero(Ty);
+ APFloat apf = cast <ConstantFP>(getNullValue(Ty))->getValueAPF();
+ apf.changeSign();
+ return getConstantFP(apf);
}
@@ -452,6 +513,17 @@
return StructType::get(Params, isPacked);
}
+StructType *LLVMContext::getStructType(const Type *type, ...) {
+ va_list ap;
+ std::vector<const llvm::Type*> StructFields;
+ va_start(ap, type);
+ while (type) {
+ StructFields.push_back(type);
+ type = va_arg(ap, llvm::Type*);
+ }
+ return StructType::get(StructFields);
+}
+
// ArrayType accessors
ArrayType* LLVMContext::getArrayType(const Type* ElementType,
uint64_t NumElements) {
Modified: llvm/trunk/tools/bugpoint/CrashDebugger.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/bugpoint/CrashDebugger.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/tools/bugpoint/CrashDebugger.cpp (original)
+++ llvm/trunk/tools/bugpoint/CrashDebugger.cpp Sun Jul 12 23:09:18 2009
@@ -299,7 +299,8 @@
if (isa<StructType>(BBTerm->getType()))
BBTerm->replaceAllUsesWith(UndefValue::get(BBTerm->getType()));
else if (BB->getTerminator()->getType() != Type::VoidTy)
- BBTerm->replaceAllUsesWith(Constant::getNullValue(BBTerm->getType()));
+ BBTerm->replaceAllUsesWith(
+ BD.getContext().getNullValue(BBTerm->getType()));
// Replace the old terminator instruction.
BB->getInstList().pop_back();
Modified: llvm/trunk/tools/bugpoint/ExtractFunction.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/bugpoint/ExtractFunction.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/tools/bugpoint/ExtractFunction.cpp (original)
+++ llvm/trunk/tools/bugpoint/ExtractFunction.cpp Sun Jul 12 23:09:18 2009
@@ -74,7 +74,7 @@
if (isa<StructType>(TheInst->getType()))
TheInst->replaceAllUsesWith(UndefValue::get(TheInst->getType()));
else if (TheInst->getType() != Type::VoidTy)
- TheInst->replaceAllUsesWith(Constant::getNullValue(TheInst->getType()));
+ TheInst->replaceAllUsesWith(Context.getNullValue(TheInst->getType()));
// Remove the instruction from the program.
TheInst->getParent()->getInstList().erase(TheInst);
Modified: llvm/trunk/tools/bugpoint/Miscompilation.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/bugpoint/Miscompilation.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/tools/bugpoint/Miscompilation.cpp (original)
+++ llvm/trunk/tools/bugpoint/Miscompilation.cpp Sun Jul 12 23:09:18 2009
@@ -711,7 +711,8 @@
// sbyte* so it matches the signature of the resolver function.
// GetElementPtr *funcName, ulong 0, ulong 0
- std::vector<Constant*> GEPargs(2,Constant::getNullValue(Type::Int32Ty));
+ std::vector<Constant*> GEPargs(2,
+ BD.getContext().getNullValue(Type::Int32Ty));
Value *GEP = ConstantExpr::getGetElementPtr(funcName, &GEPargs[0], 2);
std::vector<Value*> ResolverArgs;
ResolverArgs.push_back(GEP);
Modified: llvm/trunk/tools/bugpoint/TestPasses.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/bugpoint/TestPasses.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/tools/bugpoint/TestPasses.cpp (original)
+++ llvm/trunk/tools/bugpoint/TestPasses.cpp Sun Jul 12 23:09:18 2009
@@ -60,7 +60,7 @@
for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E; ++I)
if (CallInst *CI = dyn_cast<CallInst>(I)) {
if (!CI->use_empty())
- CI->replaceAllUsesWith(Constant::getNullValue(CI->getType()));
+ CI->replaceAllUsesWith(Context->getNullValue(CI->getType()));
CI->getParent()->getInstList().erase(CI);
break;
}
Modified: llvm/trunk/tools/lto/LTOModule.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/lto/LTOModule.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/tools/lto/LTOModule.cpp (original)
+++ llvm/trunk/tools/lto/LTOModule.cpp Sun Jul 12 23:09:18 2009
@@ -189,7 +189,7 @@
if (GlobalVariable* gvn = dyn_cast<GlobalVariable>(op)) {
Constant* cn = gvn->getInitializer();
if (ConstantArray* ca = dyn_cast<ConstantArray>(cn)) {
- if ( ca->isCString() ) {
+ if ( ca->isCString(getGlobalContext()) ) {
name = ".objc_class_name_" + ca->getAsString();
return true;
}
Modified: llvm/trunk/unittests/ExecutionEngine/JIT/JITTest.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ExecutionEngine/JIT/JITTest.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/unittests/ExecutionEngine/JIT/JITTest.cpp (original)
+++ llvm/trunk/unittests/ExecutionEngine/JIT/JITTest.cpp Sun Jul 12 23:09:18 2009
@@ -73,7 +73,7 @@
GTy,
false, // Not constant.
GlobalValue::InternalLinkage,
- Constant::getNullValue(GTy),
+ context.getNullValue(GTy),
"myglobal");
// Make a function that points to a global.
Modified: llvm/trunk/unittests/Support/ValueHandleTest.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/Support/ValueHandleTest.cpp?rev=75445&r1=75444&r2=75445&view=diff
==============================================================================
--- llvm/trunk/unittests/Support/ValueHandleTest.cpp (original)
+++ llvm/trunk/unittests/Support/ValueHandleTest.cpp Sun Jul 12 23:09:18 2009
@@ -284,14 +284,17 @@
public:
int DeletedCalls;
Value *AURWArgument;
+ LLVMContext *Context;
- RecoveringVH() : DeletedCalls(0), AURWArgument(NULL) {}
+ RecoveringVH() : DeletedCalls(0), AURWArgument(NULL),
+ Context(&getGlobalContext()) {}
RecoveringVH(Value *V)
- : CallbackVH(V), DeletedCalls(0), AURWArgument(NULL) {}
+ : CallbackVH(V), DeletedCalls(0), AURWArgument(NULL),
+ Context(&getGlobalContext()) {}
private:
virtual void deleted() {
- getValPtr()->replaceAllUsesWith(Constant::getNullValue(Type::Int32Ty));
+ getValPtr()->replaceAllUsesWith(Context->getNullValue(Type::Int32Ty));
setValPtr(NULL);
}
virtual void allUsesReplacedWith(Value *new_value) {
@@ -307,11 +310,13 @@
RecoveringVH RVH;
RVH = BitcastV.get();
std::auto_ptr<BinaryOperator> BitcastUser(
- BinaryOperator::CreateAdd(RVH, Constant::getNullValue(Type::Int32Ty)));
+ BinaryOperator::CreateAdd(RVH,
+ getGlobalContext().getNullValue(Type::Int32Ty)));
EXPECT_EQ(BitcastV.get(), BitcastUser->getOperand(0));
BitcastV.reset(); // Would crash without the ValueHandler.
- EXPECT_EQ(Constant::getNullValue(Type::Int32Ty), RVH.AURWArgument);
- EXPECT_EQ(Constant::getNullValue(Type::Int32Ty), BitcastUser->getOperand(0));
+ EXPECT_EQ(getGlobalContext().getNullValue(Type::Int32Ty), RVH.AURWArgument);
+ EXPECT_EQ(getGlobalContext().getNullValue(Type::Int32Ty),
+ BitcastUser->getOperand(0));
}
}
More information about the llvm-commits
mailing list