friend struct ConstantCreator<ConstantStruct, StructType,
std::vector<Constant*> >;
ConstantStruct(const ConstantStruct &); // DO NOT IMPLEMENT
- friend class LLVMContextImpl;
protected:
ConstantStruct(const StructType *T, const std::vector<Constant*> &Val);
public:
+ // ConstantStruct accessors
+ static Constant* get(const StructType* T, const std::vector<Constant*>& V);
+ static Constant* get(const std::vector<Constant*>& V, bool Packed = false);
+ static Constant* get(Constant* const *Vals, unsigned NumVals,
+ bool Packed = false);
+
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
friend class ConstantInt;
friend class ConstantFP;
+ friend class ConstantStruct;
public:
LLVMContext();
~LLVMContext();
// ConstantPointerNull accessors
ConstantPointerNull* getConstantPointerNull(const PointerType* T);
-
- // ConstantStruct accessors
- Constant* getConstantStruct(const StructType* T,
- const std::vector<Constant*>& V);
- Constant* getConstantStruct(const std::vector<Constant*>& V,
- bool Packed = false);
- Constant* getConstantStruct(Constant* const *Vals, unsigned NumVals,
- bool Packed = false);
// ConstantAggregateZero accessors
ConstantAggregateZero* getConstantAggregateZero(const Type* Ty);
void erase(MDNode *M);
void erase(ConstantAggregateZero *Z);
void erase(ConstantArray *Z);
- void erase(ConstantStruct *S);
void erase(ConstantVector *V);
// RAUW helpers
Constant *replaceUsesOfWithOnConstant(ConstantArray *CA,
Value *From, Value *To, Use *U);
- Constant *replaceUsesOfWithOnConstant(ConstantStruct *CS, Value *From,
- Value *To, Use *U);
};
/// FOR BACKWARDS COMPATIBILITY - Returns a global context.
ConstantInt::get(Type::Int64Ty, Hi)
};
- Constant *Init = VMContext.getConstantStruct(Elts,
- sizeof(Elts)/sizeof(Elts[0]));
+ Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
// If we already have this range, just return the uniqued version.
DIDescriptor &Entry = SimpleConstantCache[Init];
ConstantInt::get(Type::Int32Ty, RunTimeVer)
};
- Constant *Init = VMContext.getConstantStruct(Elts,
- sizeof(Elts)/sizeof(Elts[0]));
+ Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
M.addTypeName("llvm.dbg.compile_unit.type", Init->getType());
GlobalVariable *GV = new GlobalVariable(M, Init->getType(), true,
ConstantInt::get(Type::Int64Ty, Val)
};
- Constant *Init = VMContext.getConstantStruct(Elts,
- sizeof(Elts)/sizeof(Elts[0]));
+ Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
M.addTypeName("llvm.dbg.enumerator.type", Init->getType());
GlobalVariable *GV = new GlobalVariable(M, Init->getType(), true,
ConstantInt::get(Type::Int32Ty, Encoding)
};
- Constant *Init = VMContext.getConstantStruct(Elts,
- sizeof(Elts)/sizeof(Elts[0]));
+ Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
M.addTypeName("llvm.dbg.basictype.type", Init->getType());
GlobalVariable *GV = new GlobalVariable(M, Init->getType(), true,
getCastToEmpty(DerivedFrom)
};
- Constant *Init = VMContext.getConstantStruct(Elts,
- sizeof(Elts)/sizeof(Elts[0]));
+ Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
M.addTypeName("llvm.dbg.derivedtype.type", Init->getType());
GlobalVariable *GV = new GlobalVariable(M, Init->getType(), true,
ConstantInt::get(Type::Int32Ty, RuntimeLang)
};
- Constant *Init = VMContext.getConstantStruct(Elts,
- sizeof(Elts)/sizeof(Elts[0]));
+ Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
M.addTypeName("llvm.dbg.composite.type", Init->getType());
GlobalVariable *GV = new GlobalVariable(M, Init->getType(), true,
ConstantInt::get(Type::Int1Ty, isDefinition)
};
- Constant *Init = VMContext.getConstantStruct(Elts,
- sizeof(Elts)/sizeof(Elts[0]));
+ Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
M.addTypeName("llvm.dbg.subprogram.type", Init->getType());
GlobalVariable *GV = new GlobalVariable(M, Init->getType(), true,
VMContext.getConstantExprBitCast(Val, EmptyStructPtr)
};
- Constant *Init = VMContext.getConstantStruct(Elts,
- sizeof(Elts)/sizeof(Elts[0]));
+ Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
M.addTypeName("llvm.dbg.global_variable.type", Init->getType());
GlobalVariable *GV = new GlobalVariable(M, Init->getType(), true,
getCastToEmpty(Type)
};
- Constant *Init = VMContext.getConstantStruct(Elts,
- sizeof(Elts)/sizeof(Elts[0]));
+ Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
M.addTypeName("llvm.dbg.variable.type", Init->getType());
GlobalVariable *GV = new GlobalVariable(M, Init->getType(), true,
getCastToEmpty(Context)
};
- Constant *Init = VMContext.getConstantStruct(Elts,
- sizeof(Elts)/sizeof(Elts[0]));
+ Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
M.addTypeName("llvm.dbg.block.type", Init->getType());
GlobalVariable *GV = new GlobalVariable(M, Init->getType(), true,
ParseToken(lltok::rbrace, "expected end of struct constant"))
return true;
- ID.ConstantVal = Context.getConstantStruct(Elts.data(), Elts.size(), false);
+ ID.ConstantVal = ConstantStruct::get(Elts.data(), Elts.size(), false);
ID.Kind = ValID::t_Constant;
return false;
}
if (isPackedStruct) {
ID.ConstantVal =
- Context.getConstantStruct(Elts.data(), Elts.size(), true);
+ ConstantStruct::get(Elts.data(), Elts.size(), true);
ID.Kind = ValID::t_Constant;
return false;
}
NewC = Context.getConstantArray(UserCA->getType(), &NewOps[0],
NewOps.size());
} else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) {
- NewC = Context.getConstantStruct(&NewOps[0], NewOps.size(),
+ NewC = ConstantStruct::get(&NewOps[0], NewOps.size(),
UserCS->getType()->isPacked());
} else if (isa<ConstantVector>(UserC)) {
NewC = Context.getConstantVector(&NewOps[0], NewOps.size());
for (unsigned i = 0; i != Size; ++i)
Elts.push_back(ValueList.getConstantFwdRef(Record[i],
STy->getElementType(i)));
- V = Context.getConstantStruct(STy, Elts);
+ V = ConstantStruct::get(STy, Elts);
} else if (const ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) {
const Type *EltTy = ATy->getElementType();
for (unsigned i = 0; i != Size; ++i)
};
Constant *DescriptorElts[] = {
- Context.getConstantStruct(BaseElts, 2),
+ ConstantStruct::get(BaseElts, 2),
Context.getConstantArray(Context.getArrayType(VoidPtr, NumMeta),
Metadata.begin(), NumMeta)
};
- Constant *FrameMap = Context.getConstantStruct(DescriptorElts, 2);
+ Constant *FrameMap = ConstantStruct::get(DescriptorElts, 2);
std::string TypeName("gc_map.");
TypeName += utostr(NumMeta);
Operands[i] =cast<Constant>(RemapOperand(CPS->getOperand(i), ValueMap,
Context));
Result =
- Context.getConstantStruct(cast<StructType>(CPS->getType()), Operands);
+ ConstantStruct::get(cast<StructType>(CPS->getType()), Operands);
} else if (isa<ConstantPointerNull>(CPV) || isa<UndefValue>(CPV)) {
Result = const_cast<Constant*>(CPV);
} else if (const ConstantVector *CP = dyn_cast<ConstantVector>(CPV)) {
CSVals[1] = Context.getNullValue(PFTy);
CSVals[0] = ConstantInt::get(Type::Int32Ty, 2147483647);
}
- CAList.push_back(Context.getConstantStruct(CSVals));
+ CAList.push_back(ConstantStruct::get(CSVals));
}
// Create the array initializer.
Elts[Idx] = EvaluateStoreInto(Elts[Idx], Val, Addr, OpNo+1, Context);
// Return the modified struct.
- return Context.getConstantStruct(&Elts[0], Elts.size(), STy->isPacked());
+ return ConstantStruct::get(&Elts[0], Elts.size(), STy->isPacked());
} else {
ConstantInt *CI = cast<ConstantInt>(Addr->getOperand(OpNo));
const ArrayType *ATy = cast<ArrayType>(Init->getType());
Values.push_back(cast<Constant>(MV));
for (++i; i != e; ++i)
Values.push_back(cast<Constant>(MapValue(*i, VM, Context)));
- return VM[V] = Context.getConstantStruct(CS->getType(), Values);
+ return VM[V] = ConstantStruct::get(CS->getType(), Values);
}
}
return VM[V] = C;
Ops[i] = const_cast<Constant*>(Op);
}
if (isa<StructType>(AggTy))
- return Context.getConstantStruct(Ops);
+ return ConstantStruct::get(Ops);
else
return Context.getConstantArray(cast<ArrayType>(AggTy), Ops);
}
Ops[i] = const_cast<Constant*>(Op);
}
if (isa<StructType>(AggTy))
- return Context.getConstantStruct(Ops);
+ return ConstantStruct::get(Ops);
else
return Context.getConstantArray(cast<ArrayType>(AggTy), Ops);
}
}
Constant *C;
if (isa<StructType>(Agg->getType()))
- C = Context.getConstantStruct(Ops);
+ C = ConstantStruct::get(Ops);
else
C = Context.getConstantArray(cast<ArrayType>(Agg->getType()), Ops);
return C;
}
}
+// ConstantStruct accessors.
+Constant* ConstantStruct::get(const StructType* T,
+ const std::vector<Constant*>& V) {
+ LLVMContextImpl* pImpl = T->getContext().pImpl;
+
+ // Create a ConstantAggregateZero value if all elements are zeros...
+ for (unsigned i = 0, e = V.size(); i != e; ++i)
+ if (!V[i]->isNullValue())
+ // Implicitly locked.
+ return pImpl->StructConstants.getOrCreate(T, V);
+
+ return T->getContext().getConstantAggregateZero(T);
+}
+
+Constant* ConstantStruct::get(const std::vector<Constant*>& V, bool packed) {
+ std::vector<const Type*> StructEls;
+ StructEls.reserve(V.size());
+ for (unsigned i = 0, e = V.size(); i != e; ++i)
+ StructEls.push_back(V[i]->getType());
+ return get(StructType::get(StructEls, packed), V);
+}
+
+Constant* ConstantStruct::get(Constant* const *Vals, unsigned NumVals,
+ bool Packed) {
+ // FIXME: make this the primary ctor method.
+ return get(std::vector<Constant*>(Vals, Vals+NumVals), Packed);
+}
ConstantVector::ConstantVector(const VectorType *T,
const std::vector<Constant*> &V)
//
void ConstantStruct::destroyConstant() {
// Implicitly locked.
- getType()->getContext().erase(this);
+ getType()->getContext().pImpl->StructConstants.remove(this);
destroyConstantImpl();
}
destroyConstant();
}
+static std::vector<Constant*> getValType(ConstantStruct *CS) {
+ std::vector<Constant*> Elements;
+ Elements.reserve(CS->getNumOperands());
+ for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i)
+ Elements.push_back(cast<Constant>(CS->getOperand(i)));
+ return Elements;
+}
+
void ConstantStruct::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);
+
+ unsigned OperandToUpdate = U-OperandList;
+ assert(getOperand(OperandToUpdate) == From && "ReplaceAllUsesWith broken!");
+
+ std::pair<LLVMContextImpl::StructConstantsTy::MapKey, Constant*> Lookup;
+ Lookup.first.first = getType();
+ Lookup.second = this;
+ std::vector<Constant*> &Values = Lookup.first.second;
+ Values.reserve(getNumOperands()); // Build replacement struct.
+
+
+ // Fill values with the modified operands of the constant struct. Also,
+ // compute whether this turns into an all-zeros struct.
+ bool isAllZeros = false;
+ if (!ToC->isNullValue()) {
+ for (Use *O = OperandList, *E = OperandList + getNumOperands(); O != E; ++O)
+ Values.push_back(cast<Constant>(O->get()));
+ } else {
+ isAllZeros = true;
+ for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
+ Constant *Val = cast<Constant>(O->get());
+ Values.push_back(Val);
+ if (isAllZeros) isAllZeros = Val->isNullValue();
+ }
+ }
+ Values[OperandToUpdate] = ToC;
+
+ LLVMContext &Context = getType()->getContext();
+ LLVMContextImpl *pImpl = Context.pImpl;
+
+ 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::StructConstantsTy::MapTy::iterator I =
+ pImpl->StructConstants.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 struct, inserting it, replaceallusesof'ing the
+ // old with the new, then deleting the old... just update the current one
+ // in place!
+ pImpl->StructConstants.MoveConstantToNewSlot(this, I);
+
+ // Update to the new value.
+ setOperand(OperandToUpdate, ToC);
+ return;
+ }
+ }
+
+ assert(Replacement != this && "I didn't contain From!");
// Everyone using this now uses the replacement.
uncheckedReplaceAllUsesWith(Replacement);
LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
int Packed) {
- return wrap(getGlobalContext().getConstantStruct(
- unwrap<Constant>(ConstantVals, Count),
+ return wrap(ConstantStruct::get(unwrap<Constant>(ConstantVals, Count),
Count, Packed != 0));
}
return ConstantPointerNull::get(T);
}
-
-// ConstantStruct accessors.
-Constant* LLVMContext::getConstantStruct(const StructType* T,
- const std::vector<Constant*>& V) {
- return pImpl->getConstantStruct(T, V);
-}
-
-Constant* LLVMContext::getConstantStruct(const std::vector<Constant*>& V,
- bool packed) {
- std::vector<const Type*> StructEls;
- StructEls.reserve(V.size());
- for (unsigned i = 0, e = V.size(); i != e; ++i)
- StructEls.push_back(V[i]->getType());
- return getConstantStruct(getStructType(StructEls, packed), V);
-}
-
-Constant* LLVMContext::getConstantStruct(Constant* const *Vals,
- unsigned NumVals, bool Packed) {
- // FIXME: make this the primary ctor method.
- return getConstantStruct(std::vector<Constant*>(Vals, Vals+NumVals), Packed);
-}
-
-
// ConstantAggregateZero accessors.
ConstantAggregateZero* LLVMContext::getConstantAggregateZero(const Type* Ty) {
return pImpl->getConstantAggregateZero(Ty);
pImpl->erase(C);
}
-void LLVMContext::erase(ConstantStruct *S) {
- pImpl->erase(S);
-}
-
void LLVMContext::erase(ConstantVector *V) {
pImpl->erase(V);
}
Value *From, Value *To, Use *U) {
return pImpl->replaceUsesOfWithOnConstant(CA, From, To, U);
}
-
-Constant *LLVMContext::replaceUsesOfWithOnConstant(ConstantStruct *CS,
- Value *From, Value *To, Use *U) {
- return pImpl->replaceUsesOfWithOnConstant(CS, From, To, U);
-}
return Elements;
}
-static std::vector<Constant*> getValType(ConstantStruct *CS) {
- std::vector<Constant*> Elements;
- Elements.reserve(CS->getNumOperands());
- for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i)
- Elements.push_back(cast<Constant>(CS->getOperand(i)));
- return Elements;
-}
-
static std::vector<Constant*> getValType(ConstantVector *CP) {
std::vector<Constant*> Elements;
Elements.reserve(CP->getNumOperands());
return Context.getConstantAggregateZero(Ty);
}
-Constant *LLVMContextImpl::getConstantStruct(const StructType *Ty,
- const std::vector<Constant*> &V) {
- // Create a ConstantAggregateZero value if all elements are zeros...
- for (unsigned i = 0, e = V.size(); i != e; ++i)
- if (!V[i]->isNullValue())
- // Implicitly locked.
- return StructConstants.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");
ArrayConstants.remove(C);
}
-void LLVMContextImpl::erase(ConstantStruct *S) {
- StructConstants.remove(S);
-}
-
void LLVMContextImpl::erase(ConstantVector *V) {
VectorConstants.remove(V);
}
}
return Replacement;
-}
-
-Constant *LLVMContextImpl::replaceUsesOfWithOnConstant(ConstantStruct *CS,
- Value *From, Value *To, Use *U) {
- assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
- Constant *ToC = cast<Constant>(To);
-
- unsigned OperandToUpdate = U - CS->OperandList;
- assert(CS->getOperand(OperandToUpdate) == From &&
- "ReplaceAllUsesWith broken!");
-
- std::pair<StructConstantsTy::MapKey, Constant*> Lookup;
- Lookup.first.first = CS->getType();
- Lookup.second = CS;
- std::vector<Constant*> &Values = Lookup.first.second;
- Values.reserve(CS->getNumOperands()); // Build replacement struct.
-
-
- // Fill values with the modified operands of the constant struct. Also,
- // compute whether this turns into an all-zeros struct.
- bool isAllZeros = false;
- if (!ToC->isNullValue()) {
- for (Use *O = CS->OperandList, *E = CS->OperandList + CS->getNumOperands();
- O != E; ++O)
- Values.push_back(cast<Constant>(O->get()));
- } else {
- isAllZeros = true;
- for (Use *O = CS->OperandList, *E = CS->OperandList + CS->getNumOperands();
- O != E; ++O) {
- Constant *Val = cast<Constant>(O->get());
- Values.push_back(Val);
- if (isAllZeros) isAllZeros = Val->isNullValue();
- }
- }
- Values[OperandToUpdate] = ToC;
-
- Constant *Replacement = 0;
- if (isAllZeros) {
- Replacement = Context.getConstantAggregateZero(CS->getType());
- } else {
- // Check to see if we have this array type already.
- sys::SmartScopedWriter<true> Writer(ConstantsLock);
- bool Exists;
- StructConstantsTy::MapTy::iterator I =
- StructConstants.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 struct, inserting it, replaceallusesof'ing the
- // old with the new, then deleting the old... just update the current one
- // in place!
- StructConstants.MoveConstantToNewSlot(CS, I);
-
- // Update to the new value.
- CS->setOperand(OperandToUpdate, ToC);
- return 0;
- }
- }
-
- assert(Replacement != CS && "I didn't contain From!");
-
- return Replacement;
-}
+}
\ No newline at end of file
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().getConstantStruct(NewTy, C);
+ Constant *New = ConstantStruct::get(NewTy, C);
assert(New != OldC && "Didn't replace constant??");
OldC->uncheckedReplaceAllUsesWith(New);
friend class ConstantInt;
friend class ConstantFP;
+ friend class ConstantStruct;
public:
LLVMContextImpl(LLVMContext &C);
Constant *getConstantArray(const ArrayType *Ty,
const std::vector<Constant*> &V);
- Constant *getConstantStruct(const StructType *Ty,
- const std::vector<Constant*> &V);
-
Constant *getConstantVector(const VectorType *Ty,
const std::vector<Constant*> &V);
void erase(MDNode *M);
void erase(ConstantAggregateZero *Z);
void erase(ConstantArray *C);
- void erase(ConstantStruct *S);
void erase(ConstantVector *V);
// RAUW helpers
Constant *replaceUsesOfWithOnConstant(ConstantArray *CA, Value *From,
Value *To, Use *U);
- Constant *replaceUsesOfWithOnConstant(ConstantStruct *CS, Value *From,
- Value *To, Use *U);
};
}
std::vector<Constant*> Elts;
Elts.push_back(ConstantInt::get(Type::Int32Ty, TorList[i].second));
Elts.push_back(TorList[i].first);
- ArrayElts.push_back(Context.getConstantStruct(Elts));
+ ArrayElts.push_back(ConstantStruct::get(Elts));
}
return Context.getConstantArray(Context.getArrayType(ArrayElts[0]->getType(),
ArrayElts.size()),
projects / oota-llvm.git / commitdiff