RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2025-04-02 15:51:54 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Change ConstantArray to 2.5 API.

Browse Source 
llvm-svn: 77347
This commit is contained in:
Owen Anderson 2009-07-28 18:32:17 +00:00
parent 20903ee1b9
commit aa8c94b051
24 changed files with 177 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/BrainF/BrainF.cpp
View File

@ -125,7 +125,7 @@ void BrainF::header(LLVMContext& C) {
{
//@aberrormsg = internal constant [%d x i8] c"\00"
Constant *msg_0 =
C.getConstantArray("Error: The head has left the tape.", true);
ConstantArray::get("Error: The head has left the tape.", true);
GlobalVariable *aberrormsg = new GlobalVariable(
*module,

14
include/llvm/Constants.h
View File

@ -327,10 +327,22 @@ class ConstantArray : public Constant {
friend struct ConstantCreator<ConstantArray, ArrayType,
std::vector<Constant*> >;
ConstantArray(const ConstantArray &); // DO NOT IMPLEMENT
friend class LLVMContextImpl;
protected:
ConstantArray(const ArrayType *T, const std::vector<Constant*> &Val);
public:
// ConstantArray accessors
static Constant* get(const ArrayType* T, const std::vector<Constant*>& V);
static Constant* get(const ArrayType* T, Constant* const* Vals,
unsigned NumVals);
/// This method constructs a ConstantArray and initializes it with a text
/// string. The default behavior (AddNull==true) causes a null terminator to
/// be placed at the end of the array. This effectively increases the length
/// of the array by one (you've been warned). However, in some situations
/// this is not desired so if AddNull==false then the string is copied without
/// null termination.
static Constant* get(const StringRef &Initializer, bool AddNull = true);
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);

21
include/llvm/LLVMContext.h
View File

@ -58,6 +58,7 @@ class LLVMContext {
friend class ConstantInt;
friend class ConstantFP;
friend class ConstantStruct;
friend class ConstantArray;
public:
LLVMContext();
~LLVMContext();
@ -82,21 +83,6 @@ public:
// ConstantAggregateZero accessors
ConstantAggregateZero* getConstantAggregateZero(const Type* Ty);
// ConstantArray accessors
Constant* getConstantArray(const ArrayType* T,
const std::vector<Constant*>& V);
Constant* getConstantArray(const ArrayType* T, Constant* const* Vals,
unsigned NumVals);
/// This method constructs a ConstantArray and initializes it with a text
/// string. The default behavior (AddNull==true) causes a null terminator to
/// be placed at the end of the array. This effectively increases the length
/// of the array by one (you've been warned). However, in some situations
/// this is not desired so if AddNull==false then the string is copied without
/// null termination.
Constant* getConstantArray(const StringRef &Initializer,
bool AddNull = true);
// ConstantExpr accessors
Constant* getConstantExpr(unsigned Opcode, Constant* C1, Constant* C2);
@ -225,12 +211,7 @@ public:
void erase(MDString *M);
void erase(MDNode *M);
void erase(ConstantAggregateZero *Z);
void erase(ConstantArray *Z);
void erase(ConstantVector *V);
// RAUW helpers
Constant *replaceUsesOfWithOnConstant(ConstantArray *CA,
Value *From, Value *To, Use *U);
};
/// FOR BACKWARDS COMPATIBILITY - Returns a global context.

2
include/llvm/Support/IRBuilder.h
View File

@ -413,7 +413,7 @@ public:
return CreateConstGEP2_32(Ptr, 0, Idx, Name);
}
Value *CreateGlobalString(const char *Str = "", const char *Name = "") {
Constant *StrConstant = Context.getConstantArray(Str, true);
Constant *StrConstant = ConstantArray::get(Str, true);
Module &M = *BB->getParent()->getParent();
GlobalVariable *gv = new GlobalVariable(M,
StrConstant->getType(),

4
lib/Analysis/DebugInfo.cpp
View File

@ -499,7 +499,7 @@ Constant *DIFactory::GetStringConstant(const std::string &String) {
return Slot = VMContext.getConstantPointerNull(DestTy);
// Construct string as an llvm constant.
Constant *ConstStr = VMContext.getConstantArray(String);
Constant *ConstStr = ConstantArray::get(String);
// Otherwise create and return a new string global.
GlobalVariable *StrGV = new GlobalVariable(M, ConstStr->getType(), true,
@ -521,7 +521,7 @@ DIArray DIFactory::GetOrCreateArray(DIDescriptor *Tys, unsigned NumTys) {
for (unsigned i = 0; i != NumTys; ++i)
Elts.push_back(getCastToEmpty(Tys[i]));
Constant *Init = VMContext.getConstantArray(VMContext.getArrayType(EmptyStructPtr,
Constant *Init = ConstantArray::get(VMContext.getArrayType(EmptyStructPtr,
Elts.size()),
Elts.data(), Elts.size());
// If we already have this array, just return the uniqued version.

4
lib/AsmParser/LLParser.cpp
View File

@ -1811,13 +1811,13 @@ bool LLParser::ParseValID(ValID &ID) {
" is not of type '" +Elts[0]->getType()->getDescription());
}
ID.ConstantVal = Context.getConstantArray(ATy, Elts.data(), Elts.size());
ID.ConstantVal = ConstantArray::get(ATy, Elts.data(), Elts.size());
ID.Kind = ValID::t_Constant;
return false;
}
case lltok::kw_c: // c "foo"
Lex.Lex();
ID.ConstantVal = Context.getConstantArray(Lex.getStrVal(), false);
ID.ConstantVal = ConstantArray::get(Lex.getStrVal(), false);
if (ParseToken(lltok::StringConstant, "expected string")) return true;
ID.Kind = ValID::t_Constant;
return false;

8
lib/Bitcode/Reader/BitcodeReader.cpp
View File

@ -288,7 +288,7 @@ void BitcodeReaderValueList::ResolveConstantForwardRefs() {
// Make the new constant.
Constant *NewC;
if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) {
NewC = Context.getConstantArray(UserCA->getType(), &NewOps[0],
NewC = ConstantArray::get(UserCA->getType(), &NewOps[0],
NewOps.size());
} else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) {
NewC = ConstantStruct::get(&NewOps[0], NewOps.size(),
@ -930,7 +930,7 @@ bool BitcodeReader::ParseConstants() {
const Type *EltTy = ATy->getElementType();
for (unsigned i = 0; i != Size; ++i)
Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
V = Context.getConstantArray(ATy, Elts);
V = ConstantArray::get(ATy, Elts);
} else if (const VectorType *VTy = dyn_cast<VectorType>(CurTy)) {
const Type *EltTy = VTy->getElementType();
for (unsigned i = 0; i != Size; ++i)
@ -952,7 +952,7 @@ bool BitcodeReader::ParseConstants() {
std::vector<Constant*> Elts;
for (unsigned i = 0; i != Size; ++i)
Elts.push_back(ConstantInt::get(EltTy, Record[i]));
V = Context.getConstantArray(ATy, Elts);
V = ConstantArray::get(ATy, Elts);
break;
}
case bitc::CST_CODE_CSTRING: { // CSTRING: [values]
@ -967,7 +967,7 @@ bool BitcodeReader::ParseConstants() {
for (unsigned i = 0; i != Size; ++i)
Elts.push_back(ConstantInt::get(EltTy, Record[i]));
Elts.push_back(Context.getNullValue(EltTy));
V = Context.getConstantArray(ATy, Elts);
V = ConstantArray::get(ATy, Elts);
break;
}
case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval]

2
lib/CodeGen/SelectionDAG/DAGCombiner.cpp
View File

@ -5812,7 +5812,7 @@ SDValue DAGCombiner::SimplifySelectCC(DebugLoc DL, SDValue N0, SDValue N1,
const TargetData &TD = *TLI.getTargetData();
// Create a ConstantArray of the two constants.
Constant *CA = DAG.getContext()->getConstantArray(
Constant *CA = ConstantArray::get(
DAG.getContext()->getArrayType(FPTy, 2), Elts, 2);
SDValue CPIdx = DAG.getConstantPool(CA, TLI.getPointerTy(),
TD.getPrefTypeAlignment(FPTy));

2
lib/CodeGen/ShadowStackGC.cpp
View File

@ -209,7 +209,7 @@ Constant *ShadowStackGC::GetFrameMap(Function &F) {
Constant *DescriptorElts[] = {
ConstantStruct::get(BaseElts, 2),
Context.getConstantArray(Context.getArrayType(VoidPtr, NumMeta),
ConstantArray::get(Context.getArrayType(VoidPtr, NumMeta),
Metadata.begin(), NumMeta)
};

4
lib/Linker/LinkModules.cpp
View File

@ -369,7 +369,7 @@ static Value *RemapOperand(const Value *In,
Operands[i] =cast<Constant>(RemapOperand(CPA->getOperand(i), ValueMap,
Context));
Result =
Context.getConstantArray(cast<ArrayType>(CPA->getType()), Operands);
ConstantArray::get(cast<ArrayType>(CPA->getType()), Operands);
} else if (const ConstantStruct *CPS = dyn_cast<ConstantStruct>(CPV)) {
std::vector<Constant*> Operands(CPS->getNumOperands());
for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i)
@ -1186,7 +1186,7 @@ static bool LinkAppendingVars(Module *M,
for (unsigned i = 0, e = T2->getNumElements(); i != e; ++i)
Inits.push_back(CV);
}
NG->setInitializer(Context.getConstantArray(NewType, Inits));
NG->setInitializer(ConstantArray::get(NewType, Inits));
Inits.clear();
// Replace any uses of the two global variables with uses of the new

2
lib/Target/XCore/XCoreTargetObjectFile.cpp
View File

@ -29,4 +29,4 @@ XCoreTargetObjectFile::XCoreTargetObjectFile(bool isXS1A) {
else
ReadOnlySection = getOrCreateSection("\t.cp.rodata", false,
SectionKind::ReadOnly);
}
}

2
lib/Transforms/IPO/ExtractGV.cpp
View File

@ -110,7 +110,7 @@ namespace {
AUGs.push_back(Context.getConstantExprBitCast(*GI, SBP));
}
ArrayType *AT = Context.getArrayType(SBP, AUGs.size());
Constant *Init = Context.getConstantArray(AT, AUGs);
Constant *Init = ConstantArray::get(AT, AUGs);
GlobalValue *gv = new GlobalVariable(M, AT, false,
GlobalValue::AppendingLinkage,
Init, "llvm.used");

4
lib/Transforms/IPO/GlobalOpt.cpp
View File

@ -1968,7 +1968,7 @@ static GlobalVariable *InstallGlobalCtors(GlobalVariable *GCL,
// Create the array initializer.
const Type *StructTy =
cast<ArrayType>(GCL->getType()->getElementType())->getElementType();
Constant *CA = Context.getConstantArray(ArrayType::get(StructTy,
Constant *CA = ConstantArray::get(ArrayType::get(StructTy,
CAList.size()), CAList);
// If we didn't change the number of elements, don't create a new GV.
@ -2094,7 +2094,7 @@ static Constant *EvaluateStoreInto(Constant *Init, Constant *Val,
assert(CI->getZExtValue() < ATy->getNumElements());
Elts[CI->getZExtValue()] =
EvaluateStoreInto(Elts[CI->getZExtValue()], Val, Addr, OpNo+1, Context);
return Context.getConstantArray(ATy, Elts);
return ConstantArray::get(ATy, Elts);
}
}

2
lib/Transforms/Scalar/SimplifyLibCalls.cpp
View File

@ -1290,7 +1290,7 @@ struct VISIBILITY_HIDDEN PrintFOpt : public LibCallOptimization {
// Create a string literal with no \n on it. We expect the constant merge
// pass to be run after this pass, to merge duplicate strings.
FormatStr.erase(FormatStr.end()-1);
Constant *C = Context->getConstantArray(FormatStr, true);
Constant *C = ConstantArray::get(FormatStr, true);
C = new GlobalVariable(*Callee->getParent(), C->getType(), true,
GlobalVariable::InternalLinkage, C, "str");
EmitPutS(C, B);

4
lib/Transforms/Utils/LowerInvoke.cpp
View File

@ -183,7 +183,7 @@ void LowerInvoke::createAbortMessage(Module *M) {
// The abort message for expensive EH support tells the user that the
// program 'unwound' without an 'invoke' instruction.
Constant *Msg =
Context.getConstantArray("ERROR: Exception thrown, but not caught!\n");
ConstantArray::get("ERROR: Exception thrown, but not caught!\n");
AbortMessageLength = Msg->getNumOperands()-1; // don't include \0
GlobalVariable *MsgGV = new GlobalVariable(*M, Msg->getType(), true,
@ -195,7 +195,7 @@ void LowerInvoke::createAbortMessage(Module *M) {
// The abort message for cheap EH support tells the user that EH is not
// enabled.
Constant *Msg =
Context.getConstantArray("Exception handler needed, but not enabled."
ConstantArray::get("Exception handler needed, but not enabled."
"Recompile program with -enable-correct-eh-support.\n");
AbortMessageLength = Msg->getNumOperands()-1; // don't include \0

2
lib/Transforms/Utils/ValueMapper.cpp
View File

@ -56,7 +56,7 @@ Value *llvm::MapValue(const Value *V, ValueMapTy &VM, LLVMContext &Context) {
Values.push_back(cast<Constant>(MV));
for (++i; i != e; ++i)
Values.push_back(cast<Constant>(MapValue(*i, VM, Context)));
return VM[V] = Context.getConstantArray(CA->getType(), Values);
return VM[V] = ConstantArray::get(CA->getType(), Values);
}
}
return VM[V] = C;

6
lib/VMCore/ConstantFold.cpp
View File

@ -521,7 +521,7 @@ Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context,
if (isa<StructType>(AggTy))
return ConstantStruct::get(Ops);
else
return Context.getConstantArray(cast<ArrayType>(AggTy), Ops);
return ConstantArray::get(cast<ArrayType>(AggTy), Ops);
}
if (isa<ConstantAggregateZero>(Agg)) {
// Insertion of constant into aggregate zero
@ -550,7 +550,7 @@ Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context,
if (isa<StructType>(AggTy))
return ConstantStruct::get(Ops);
else
return Context.getConstantArray(cast<ArrayType>(AggTy), Ops);
return ConstantArray::get(cast<ArrayType>(AggTy), Ops);
}
if (isa<ConstantStruct>(Agg) || isa<ConstantArray>(Agg)) {
// Insertion of constant into aggregate constant
@ -567,7 +567,7 @@ Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context,
if (isa<StructType>(Agg->getType()))
C = ConstantStruct::get(Ops);
else
C = Context.getConstantArray(cast<ArrayType>(Agg->getType()), Ops);
C = ConstantArray::get(cast<ArrayType>(Agg->getType()), Ops);
return C;
}

137
lib/VMCore/Constants.cpp
View File

@ -375,6 +375,54 @@ ConstantArray::ConstantArray(const ArrayType *T,
}
}
Constant *ConstantArray::get(const ArrayType *Ty,
const std::vector<Constant*> &V) {
LLVMContextImpl *pImpl = Ty->getContext().pImpl;
// If this is an all-zero array, return a ConstantAggregateZero object
if (!V.empty()) {
Constant *C = V[0];
if (!C->isNullValue()) {
// Implicitly locked.
return pImpl->ArrayConstants.getOrCreate(Ty, V);
}
for (unsigned i = 1, e = V.size(); i != e; ++i)
if (V[i] != C) {
// Implicitly locked.
return pImpl->ArrayConstants.getOrCreate(Ty, V);
}
}
return Ty->getContext().getConstantAggregateZero(Ty);
}
Constant* ConstantArray::get(const ArrayType* T, Constant* const* Vals,
unsigned NumVals) {
// FIXME: make this the primary ctor method.
return get(T, std::vector<Constant*>(Vals, Vals+NumVals));
}
/// ConstantArray::get(const string&) - Return an array that is initialized to
/// contain the specified string. If length is zero then a null terminator is
/// added to the specified string so that it may be used in a natural way.
/// Otherwise, the length parameter specifies how much of the string to use
/// and it won't be null terminated.
///
Constant* ConstantArray::get(const StringRef &Str, bool AddNull) {
std::vector<Constant*> ElementVals;
for (unsigned i = 0; i < Str.size(); ++i)
ElementVals.push_back(ConstantInt::get(Type::Int8Ty, Str[i]));
// Add a null terminator to the string...
if (AddNull) {
ElementVals.push_back(ConstantInt::get(Type::Int8Ty, 0));
}
ArrayType *ATy = ArrayType::get(Type::Int8Ty, ElementVals.size());
return get(ATy, ElementVals);
}
ConstantStruct::ConstantStruct(const StructType *T,
const std::vector<Constant*> &V)
@ -943,7 +991,7 @@ void ConstantAggregateZero::destroyConstant() {
///
void ConstantArray::destroyConstant() {
// Implicitly locked.
getType()->getContext().erase(this);
getType()->getContext().pImpl->ArrayConstants.remove(this);
destroyConstantImpl();
}
@ -1907,12 +1955,91 @@ const char *ConstantExpr::getOpcodeName() const {
/// single invocation handles all 1000 uses. Handling them one at a time would
/// work, but would be really slow because it would have to unique each updated
/// array instance.
static std::vector<Constant*> getValType(ConstantArray *CA) {
std::vector<Constant*> Elements;
Elements.reserve(CA->getNumOperands());
for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i)
Elements.push_back(cast<Constant>(CA->getOperand(i)));
return Elements;
}
void ConstantArray::replaceUsesOfWithOnConstant(Value *From, Value *To,
Use *U) {
Constant *Replacement =
getType()->getContext().replaceUsesOfWithOnConstant(this, From, To, U);
if (!Replacement) return;
assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
Constant *ToC = cast<Constant>(To);
LLVMContext &Context = getType()->getContext();
LLVMContextImpl *pImpl = Context.pImpl;
std::pair<LLVMContextImpl::ArrayConstantsTy::MapKey, Constant*> Lookup;
Lookup.first.first = getType();
Lookup.second = this;
std::vector<Constant*> &Values = Lookup.first.second;
Values.reserve(getNumOperands()); // Build replacement array.
// Fill values with the modified operands of the constant array. Also,
// compute whether this turns into an all-zeros array.
bool isAllZeros = false;
unsigned NumUpdated = 0;
if (!ToC->isNullValue()) {
for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
Constant *Val = cast<Constant>(O->get());
if (Val == From) {
Val = ToC;
++NumUpdated;
}
Values.push_back(Val);
}
} else {
isAllZeros = true;
for (Use *O = OperandList, *E = OperandList+getNumOperands();O != E; ++O) {
Constant *Val = cast<Constant>(O->get());
if (Val == From) {
Val = ToC;
++NumUpdated;
}
Values.push_back(Val);
if (isAllZeros) isAllZeros = Val->isNullValue();
}
}
Constant *Replacement = 0;
if (isAllZeros) {
Replacement = Context.getConstantAggregateZero(getType());
} else {
// Check to see if we have this array type already.
sys::SmartScopedWriter<true> Writer(pImpl->ConstantsLock);
bool Exists;
LLVMContextImpl::ArrayConstantsTy::MapTy::iterator I =
pImpl->ArrayConstants.InsertOrGetItem(Lookup, Exists);
if (Exists) {
Replacement = I->second;
} else {
// Okay, the new shape doesn't exist in the system yet. Instead of
// creating a new constant array, inserting it, replaceallusesof'ing the
// old with the new, then deleting the old... just update the current one
// in place!
pImpl->ArrayConstants.MoveConstantToNewSlot(this, I);
// Update to the new value. Optimize for the case when we have a single
// operand that we're changing, but handle bulk updates efficiently.
if (NumUpdated == 1) {
unsigned OperandToUpdate = U - OperandList;
assert(getOperand(OperandToUpdate) == From &&
"ReplaceAllUsesWith broken!");
setOperand(OperandToUpdate, ToC);
} else {
for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
if (getOperand(i) == From)
setOperand(i, ToC);
}
return;
}
}
// Otherwise, I do need to replace this with an existing value.
assert(Replacement != this && "I didn't contain From!");

4
lib/VMCore/Core.cpp
View File

@ -402,13 +402,13 @@ LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
int DontNullTerminate) {
/* Inverted the sense of AddNull because ', 0)' is a
better mnemonic for null termination than ', 1)'. */
return wrap(getGlobalContext().getConstantArray(std::string(Str, Length),
return wrap(ConstantArray::get(std::string(Str, Length),
DontNullTerminate == 0));
}
LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
LLVMValueRef *ConstantVals, unsigned Length) {
return wrap(getGlobalContext().getConstantArray(
return wrap(ConstantArray::get(
getGlobalContext().getArrayType(unwrap(ElementTy), Length),
unwrap<Constant>(ConstantVals, Length),
Length));

45
lib/VMCore/LLVMContext.cpp
View File

@ -103,42 +103,6 @@ ConstantAggregateZero* LLVMContext::getConstantAggregateZero(const Type* Ty) {
return pImpl->getConstantAggregateZero(Ty);
}
// ConstantArray accessors.
Constant* LLVMContext::getConstantArray(const ArrayType* T,
const std::vector<Constant*>& V) {
return pImpl->getConstantArray(T, V);
}
Constant* LLVMContext::getConstantArray(const ArrayType* T,
Constant* const* Vals,
unsigned NumVals) {
// FIXME: make this the primary ctor method.
return getConstantArray(T, std::vector<Constant*>(Vals, Vals+NumVals));
}
/// ConstantArray::get(const string&) - Return an array that is initialized to
/// contain the specified string. If length is zero then a null terminator is
/// added to the specified string so that it may be used in a natural way.
/// Otherwise, the length parameter specifies how much of the string to use
/// and it won't be null terminated.
///
Constant* LLVMContext::getConstantArray(const StringRef &Str,
bool AddNull) {
std::vector<Constant*> ElementVals;
for (unsigned i = 0; i < Str.size(); ++i)
ElementVals.push_back(ConstantInt::get(Type::Int8Ty, Str[i]));
// Add a null terminator to the string...
if (AddNull) {
ElementVals.push_back(ConstantInt::get(Type::Int8Ty, 0));
}
ArrayType *ATy = getArrayType(Type::Int8Ty, ElementVals.size());
return getConstantArray(ATy, ElementVals);
}
// ConstantExpr accessors.
Constant* LLVMContext::getConstantExpr(unsigned Opcode, Constant* C1,
Constant* C2) {
@ -525,15 +489,6 @@ void LLVMContext::erase(ConstantAggregateZero *Z) {
pImpl->erase(Z);
}
void LLVMContext::erase(ConstantArray *C) {
pImpl->erase(C);
}
void LLVMContext::erase(ConstantVector *V) {
pImpl->erase(V);
}
Constant *LLVMContext::replaceUsesOfWithOnConstant(ConstantArray *CA,
Value *From, Value *To, Use *U) {
return pImpl->replaceUsesOfWithOnConstant(CA, From, To, U);
}

111
lib/VMCore/LLVMContextImpl.cpp
View File

@ -21,14 +21,6 @@ using namespace llvm;
static char getValType(ConstantAggregateZero *CPZ) { return 0; }
static std::vector<Constant*> getValType(ConstantArray *CA) {
std::vector<Constant*> Elements;
Elements.reserve(CA->getNumOperands());
for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i)
Elements.push_back(cast<Constant>(CA->getOperand(i)));
return Elements;
}
static std::vector<Constant*> getValType(ConstantVector *CP) {
std::vector<Constant*> Elements;
Elements.reserve(CP->getNumOperands());
@ -85,25 +77,6 @@ LLVMContextImpl::getConstantAggregateZero(const Type *Ty) {
return AggZeroConstants.getOrCreate(Ty, 0);
}
Constant *LLVMContextImpl::getConstantArray(const ArrayType *Ty,
const std::vector<Constant*> &V) {
// If this is an all-zero array, return a ConstantAggregateZero object
if (!V.empty()) {
Constant *C = V[0];
if (!C->isNullValue()) {
// Implicitly locked.
return ArrayConstants.getOrCreate(Ty, V);
}
for (unsigned i = 1, e = V.size(); i != e; ++i)
if (V[i] != C) {
// Implicitly locked.
return ArrayConstants.getOrCreate(Ty, V);
}
}
return Context.getConstantAggregateZero(Ty);
}
Constant *LLVMContextImpl::getConstantVector(const VectorType *Ty,
const std::vector<Constant*> &V) {
assert(!V.empty() && "Vectors can't be empty");
@ -146,90 +119,6 @@ void LLVMContextImpl::erase(ConstantAggregateZero *Z) {
AggZeroConstants.remove(Z);
}
void LLVMContextImpl::erase(ConstantArray *C) {
ArrayConstants.remove(C);
}
void LLVMContextImpl::erase(ConstantVector *V) {
VectorConstants.remove(V);
}
// *** RAUW helpers ***
Constant *LLVMContextImpl::replaceUsesOfWithOnConstant(ConstantArray *CA,
Value *From, Value *To, Use *U) {
assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
Constant *ToC = cast<Constant>(To);
std::pair<ArrayConstantsTy::MapKey, Constant*> Lookup;
Lookup.first.first = CA->getType();
Lookup.second = CA;
std::vector<Constant*> &Values = Lookup.first.second;
Values.reserve(CA->getNumOperands()); // Build replacement array.
// Fill values with the modified operands of the constant array. Also,
// compute whether this turns into an all-zeros array.
bool isAllZeros = false;
unsigned NumUpdated = 0;
if (!ToC->isNullValue()) {
for (Use *O = CA->OperandList, *E = CA->OperandList + CA->getNumOperands();
O != E; ++O) {
Constant *Val = cast<Constant>(O->get());
if (Val == From) {
Val = ToC;
++NumUpdated;
}
Values.push_back(Val);
}
} else {
isAllZeros = true;
for (Use *O = CA->OperandList, *E = CA->OperandList + CA->getNumOperands();
O != E; ++O) {
Constant *Val = cast<Constant>(O->get());
if (Val == From) {
Val = ToC;
++NumUpdated;
}
Values.push_back(Val);
if (isAllZeros) isAllZeros = Val->isNullValue();
}
}
Constant *Replacement = 0;
if (isAllZeros) {
Replacement = Context.getConstantAggregateZero(CA->getType());
} else {
// Check to see if we have this array type already.
sys::SmartScopedWriter<true> Writer(ConstantsLock);
bool Exists;
ArrayConstantsTy::MapTy::iterator I =
ArrayConstants.InsertOrGetItem(Lookup, Exists);
if (Exists) {
Replacement = I->second;
} else {
// Okay, the new shape doesn't exist in the system yet. Instead of
// creating a new constant array, inserting it, replaceallusesof'ing the
// old with the new, then deleting the old... just update the current one
// in place!
ArrayConstants.MoveConstantToNewSlot(CA, I);
// Update to the new value. Optimize for the case when we have a single
// operand that we're changing, but handle bulk updates efficiently.
if (NumUpdated == 1) {
unsigned OperandToUpdate = U - CA->OperandList;
assert(CA->getOperand(OperandToUpdate) == From &&
"ReplaceAllUsesWith broken!");
CA->setOperand(OperandToUpdate, ToC);
} else {
for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i)
if (CA->getOperand(i) == From)
CA->setOperand(i, ToC);
}
return 0;
}
}
return Replacement;
}

12
lib/VMCore/LLVMContextImpl.h
View File

@ -88,7 +88,7 @@ struct ConvertConstantType<ConstantArray, ArrayType> {
std::vector<Constant*> C;
for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i)
C.push_back(cast<Constant>(OldC->getOperand(i)));
Constant *New = NewTy->getContext().getConstantArray(NewTy, C);
Constant *New = ConstantArray::get(NewTy, C);
assert(New != OldC && "Didn't replace constant??");
OldC->uncheckedReplaceAllUsesWith(New);
OldC->destroyConstant(); // This constant is now dead, destroy it.
@ -459,6 +459,7 @@ class LLVMContextImpl {
friend class ConstantInt;
friend class ConstantFP;
friend class ConstantStruct;
friend class ConstantArray;
public:
LLVMContextImpl(LLVMContext &C);
@ -468,9 +469,6 @@ public:
ConstantAggregateZero *getConstantAggregateZero(const Type *Ty);
Constant *getConstantArray(const ArrayType *Ty,
const std::vector<Constant*> &V);
Constant *getConstantVector(const VectorType *Ty,
const std::vector<Constant*> &V);
@ -491,13 +489,7 @@ public:
void erase(MDString *M);
void erase(MDNode *M);
void erase(ConstantAggregateZero *Z);
void erase(ConstantArray *C);
void erase(ConstantVector *V);
// RAUW helpers
Constant *replaceUsesOfWithOnConstant(ConstantArray *CA, Value *From,
Value *To, Use *U);
};
}

2
tools/bugpoint/ExtractFunction.cpp
View File

@ -189,7 +189,7 @@ static Constant *GetTorInit(std::vector<std::pair<Function*, int> > &TorList) {
Elts.push_back(TorList[i].first);
ArrayElts.push_back(ConstantStruct::get(Elts));
}
return Context.getConstantArray(Context.getArrayType(ArrayElts[0]->getType(),
return ConstantArray::get(Context.getArrayType(ArrayElts[0]->getType(),
ArrayElts.size()),
ArrayElts);
}

2
tools/bugpoint/Miscompilation.cpp
View File

@ -709,7 +709,7 @@ static void CleanupAndPrepareModules(BugDriver &BD, Module *&Test,
// Don't forward functions which are external in the test module too.
if (TestFn && !TestFn->isDeclaration()) {
// 1. Add a string constant with its name to the global file
Constant *InitArray = Context.getConstantArray(F->getName());
Constant *InitArray = ConstantArray::get(F->getName());
GlobalVariable *funcName =
new GlobalVariable(*Safe, InitArray->getType(), true /*isConstant*/,
GlobalValue::InternalLinkage, InitArray,