StackState &SS = Stack.back();
if (const StructType *ST = dyn_cast<StructType>(SS.Ty)) {
++SS.Idx;
- if (SS.Idx != ST->getElementTypes().size()) {
+ if (SS.Idx != ST->getNumElements()) {
const StructLayout *SL = TD.getStructLayout(ST);
SS.Offset += SL->MemberOffsets[SS.Idx]-SL->MemberOffsets[SS.Idx-1];
return;
while (!Stack.empty() && !Stack.back().Ty->isFirstClassType()) {
StackState &SS = Stack.back();
if (const StructType *ST = dyn_cast<StructType>(SS.Ty)) {
- if (ST->getElementTypes().empty()) {
+ if (ST->getNumElements() == 0) {
assert(SS.Idx == 0);
PopStackAndAdvance();
} else {
// Step into the structure...
- assert(SS.Idx < ST->getElementTypes().size());
+ assert(SS.Idx < ST->getNumElements());
const StructLayout *SL = TD.getStructLayout(ST);
- Stack.push_back(StackState(ST->getElementTypes()[SS.Idx],
+ Stack.push_back(StackState(ST->getElementType(SS.Idx),
SS.Offset+SL->MemberOffsets[SS.Idx]));
}
} else {
/* empty */;
// The offset we are looking for must be in the i'th element...
- SubType = STy->getElementTypes()[i];
+ SubType = STy->getElementType(i);
O += SL.MemberOffsets[i];
break;
}
NextPadSize = SL.MemberOffsets[1];
else
NextPadSize = SubTypeSize;
- NextSubType = STy->getElementTypes()[0];
+ NextSubType = STy->getElementType(0);
NextSubTypeSize = TD.getTypeSize(NextSubType);
break;
}
// Check to ensure that constants are compatible with the type initializer!
for (unsigned i = 0, e = $3->size(); i != e; ++i)
- if ((*$3)[i]->getType() != STy->getElementTypes()[i])
+ if ((*$3)[i]->getType() != STy->getElementType(i))
ThrowException("Expected type '" +
- STy->getElementTypes()[i]->getDescription() +
+ STy->getElementType(i)->getDescription() +
"' for element #" + utostr(i) +
" of structure initializer!");
case Type::StructTyID: {
const StructType *ST = cast<StructType>(Ty);
- const StructType::ElementTypes &ET = ST->getElementTypes();
std::vector<Constant *> Elements;
- Elements.reserve(ET.size());
- for (unsigned i = 0; i != ET.size(); ++i)
- Elements.push_back(getConstantValue(ET[i], read_vbr_uint(Buf, EndBuf)));
+ Elements.reserve(ST->getNumElements());
+ for (unsigned i = 0; i != ST->getNumElements(); ++i)
+ Elements.push_back(getConstantValue(ST->getElementType(i),
+ read_vbr_uint(Buf, EndBuf)));
return ConstantStruct::get(ST, Elements);
}
const StructType *ST = cast<StructType>(T);
// Output all of the element types...
- StructType::ElementTypes::const_iterator I = ST->getElementTypes().begin();
- for (; I != ST->getElementTypes().end(); ++I) {
+ for (StructType::element_iterator I = ST->element_begin(),
+ E = ST->element_end(); I != E; ++I) {
int Slot = Table.getSlot(*I);
assert(Slot != -1 && "Type used but not available!!");
output_vbr((unsigned)Slot, Out);
const StructType *STy = cast<StructType>(Ty);
Out << NameSoFar + " {\n";
unsigned Idx = 0;
- for (StructType::ElementTypes::const_iterator
- I = STy->getElementTypes().begin(),
- E = STy->getElementTypes().end(); I != E; ++I) {
+ for (StructType::element_iterator I = STy->element_begin(),
+ E = STy->element_end(); I != E; ++I) {
Out << " ";
printType(Out, *I, "field" + utostr(Idx++));
Out << ";\n";
//Check to see if we have already printed this struct
if (StructPrinted.count(STy) == 0) {
// Print all contained types first...
- for (StructType::ElementTypes::const_iterator
- I = STy->getElementTypes().begin(),
- E = STy->getElementTypes().end(); I != E; ++I) {
+ for (StructType::element_iterator I = STy->element_begin(),
+ E = STy->element_end(); I != E; ++I) {
const Type *Ty1 = I->get();
if (isa<StructType>(Ty1) || isa<ArrayType>(Ty1))
printContainedStructs(*I, StructPrinted);
const StructType *STy = cast<StructType>(Ty);
Out << NameSoFar + " {\n";
unsigned Idx = 0;
- for (StructType::ElementTypes::const_iterator
- I = STy->getElementTypes().begin(),
- E = STy->getElementTypes().end(); I != E; ++I) {
+ for (StructType::element_iterator I = STy->element_begin(),
+ E = STy->element_end(); I != E; ++I) {
Out << " ";
printType(Out, *I, "field" + utostr(Idx++));
Out << ";\n";
//Check to see if we have already printed this struct
if (StructPrinted.count(STy) == 0) {
// Print all contained types first...
- for (StructType::ElementTypes::const_iterator
- I = STy->getElementTypes().begin(),
- E = STy->getElementTypes().end(); I != E; ++I) {
+ for (StructType::element_iterator I = STy->element_begin(),
+ E = STy->element_end(); I != E; ++I) {
const Type *Ty1 = I->get();
if (isa<StructType>(Ty1) || isa<ArrayType>(Ty1))
printContainedStructs(*I, StructPrinted);
StructSize = 0;
// Loop over each of the elements, placing them in memory...
- for (StructType::ElementTypes::const_iterator
- TI = ST->getElementTypes().begin(),
- TE = ST->getElementTypes().end(); TI != TE; ++TI) {
+ for (StructType::element_iterator TI = ST->element_begin(),
+ TE = ST->element_end(); TI != TE; ++TI) {
const Type *Ty = *TI;
unsigned char A;
unsigned TyAlign;
Result += Layout->MemberOffsets[FieldNo];
// Update Ty to refer to current element
- Ty = STy->getElementTypes()[FieldNo];
+ Ty = STy->getElementType(FieldNo);
}
}
}
// The next type is the member of the structure selected by the
// index.
- Ty = StTy->getElementTypes()[idxValue];
+ Ty = StTy->getElementType(idxValue);
} else if (const SequentialType *SqTy = cast<SequentialType>(Ty)) {
// It's an array or pointer access: [ArraySize x ElementType].
}
// The next type is the member of the structure selected by the
// index.
- Ty = StTy->getElementTypes()[idxValue];
+ Ty = StTy->getElementType(idxValue);
} else if (const SequentialType *SqTy = cast<SequentialType>(Ty)) {
// It's an array or pointer access: [ArraySize x ElementType].
}
case Type::StructTyID: {
const StructType *ST = cast<StructType>(Ty);
- const StructType::ElementTypes &El = ST->getElementTypes();
std::vector<const Type *> Types;
- for (StructType::ElementTypes::const_iterator I = El.begin(), E = El.end();
- I != E; ++I)
+ for (StructType::element_iterator I = ST->element_begin(),
+ E = ST->element_end(); I != E; ++I)
Types.push_back(ConvertType(*I));
DestTy = StructType::get(Types);
break;
if (const StructType *OldST = dyn_cast<StructType>(OldTy)) {
// Figure out what the current index is...
unsigned ElNum = cast<ConstantUInt>(Idx[i])->getValue();
- assert(ElNum < OldST->getElementTypes().size());
+ assert(ElNum < OldST->getNumElements());
std::map<const StructType*, TransformType>::iterator
I = Transforms.find(OldST);
const StructType *OldTy = I->first;
const std::vector<int> &InVec = I->second;
- assert(OldTy->getElementTypes().size() == InVec.size() &&
+ assert(OldTy->getNumElements() == InVec.size() &&
"Action not specified for every element of structure type!");
std::vector<const Type *> NewType;
static inline void GetTransformation(const TargetData &TD, const StructType *ST,
std::vector<int> &Transform,
enum SimpleStructMutation::Transform XForm) {
- unsigned NumElements = ST->getElementTypes().size();
+ unsigned NumElements = ST->getNumElements();
Transform.reserve(NumElements);
switch (XForm) {
// Build mapping from index to size
for (unsigned i = 0; i < NumElements; ++i)
- ElList.push_back(
- std::make_pair(i, TD.getTypeSize(ST->getElementTypes()[i])));
+ ElList.push_back(std::make_pair(i,TD.getTypeSize(ST->getElementType(i))));
sort(ElList.begin(), ElList.end(), ptr_fun(FirstLess));
const Type *IdxType;
if (const StructType *CurSTy = dyn_cast<StructType>(CurCTy)) {
// Check for a zero element struct type... if we have one, bail.
- if (CurSTy->getElementTypes().size() == 0) break;
+ if (CurSTy->getNumElements() == 0) break;
// Grab the first element of the struct type, which must lie at
// offset zero in the struct.
//
- ElTy = CurSTy->getElementTypes()[0];
+ ElTy = CurSTy->getElementType(0);
IdxType = Type::UByteTy; // FIXME when PR82 is fixed.
} else {
ElTy = cast<ArrayType>(CurCTy)->getElementType();
uint64_t ThisOffset;
const Type *NextType;
if (const StructType *STy = dyn_cast<StructType>(Ty)) {
- if (STy->getElementTypes().empty()) {
+ if (STy->getNumElements()) {
Offset = 0;
return STy;
}
case Type::StructTyID: {
const StructType *STy = cast<StructType>(Ty);
Result = "{ ";
- for (StructType::ElementTypes::const_iterator
- I = STy->getElementTypes().begin(),
- E = STy->getElementTypes().end(); I != E; ++I) {
- if (I != STy->getElementTypes().begin())
+ for (StructType::element_iterator I = STy->element_begin(),
+ E = STy->element_end(); I != E; ++I) {
+ if (I != STy->element_begin())
Result += ", ";
Result += calcTypeName(*I, TypeStack, TypeNames);
}
Out << ")";
} else if (const StructType *STy = dyn_cast<StructType>(Ty)) {
Out << "{ ";
- for (StructType::ElementTypes::const_iterator
- I = STy->getElementTypes().begin(),
- E = STy->getElementTypes().end(); I != E; ++I) {
- if (I != STy->getElementTypes().begin())
+ for (StructType::element_iterator I = STy->element_begin(),
+ E = STy->element_end(); I != E; ++I) {
+ if (I != STy->element_begin())
Out << ", ";
printType(*I);
}
case Type::StructTyID: {
const StructType *ST = cast<StructType>(Ty);
- const StructType::ElementTypes &ETs = ST->getElementTypes();
std::vector<Constant*> Elements;
- Elements.resize(ETs.size());
- for (unsigned i = 0, e = ETs.size(); i != e; ++i)
- Elements[i] = Constant::getNullValue(ETs[i]);
+ Elements.resize(ST->getNumElements());
+ for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i)
+ Elements[i] = Constant::getNullValue(ST->getElementType(i));
return ConstantStruct::get(ST, Elements);
}
case Type::ArrayTyID: {
ConstantStruct::ConstantStruct(const StructType *T,
const std::vector<Constant*> &V) : Constant(T) {
- const StructType::ElementTypes &ETypes = T->getElementTypes();
- assert(V.size() == ETypes.size() &&
+ assert(V.size() == T->getNumElements() &&
"Invalid initializer vector for constant structure");
Operands.reserve(V.size());
for (unsigned i = 0, e = V.size(); i != e; ++i) {
- assert((V[i]->getType() == ETypes[i] ||
- ((ETypes[i]->isAbstract() || V[i]->getType()->isAbstract()) &&
- ETypes[i]->getPrimitiveID()==V[i]->getType()->getPrimitiveID())) &&
+ assert((V[i]->getType() == T->getElementType(i) ||
+ ((T->getElementType(i)->isAbstract() ||
+ V[i]->getType()->isAbstract()) &&
+ T->getElementType(i)->getPrimitiveID() ==
+ V[i]->getType()->getPrimitiveID())) &&
"Initializer for struct element doesn't match struct element type!");
Operands.push_back(Use(V[i], this));
}
case Type::StructTyID: {
const StructType *STy = cast<StructType>(Ty);
Result = "{ ";
- for (StructType::ElementTypes::const_iterator
- I = STy->getElementTypes().begin(),
- E = STy->getElementTypes().end(); I != E; ++I) {
- if (I != STy->getElementTypes().begin())
+ for (StructType::element_iterator I = STy->element_begin(),
+ E = STy->element_end(); I != E; ++I) {
+ if (I != STy->element_begin())
Result += ", ";
Result += getTypeDescription(*I, TypeStack);
}
return TypesEqual(PTy->getElementType(),
cast<PointerType>(Ty2)->getElementType(), EqTypes);
} else if (const StructType *STy = dyn_cast<StructType>(Ty)) {
- const StructType::ElementTypes &STyE = STy->getElementTypes();
- const StructType::ElementTypes &STyE2 =
- cast<StructType>(Ty2)->getElementTypes();
- if (STyE.size() != STyE2.size()) return false;
- for (unsigned i = 0, e = STyE.size(); i != e; ++i)
- if (!TypesEqual(STyE[i], STyE2[i], EqTypes))
+ const StructType *STy2 = cast<StructType>(Ty2);
+ if (STy->getNumElements() != STy2->getNumElements()) return false;
+ for (unsigned i = 0, e = STy2->getNumElements(); i != e; ++i)
+ if (!TypesEqual(STy->getElementType(i), STy2->getElementType(i), EqTypes))
return false;
return true;
} else if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
static StructValType get(const StructType *ST) {
std::vector<const Type *> ElTypes;
- ElTypes.reserve(ST->getElementTypes().size());
- for (unsigned i = 0, e = ST->getElementTypes().size(); i != e; ++i)
- ElTypes.push_back(ST->getElementTypes()[i]);
+ ElTypes.reserve(ST->getNumElements());
+ for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i)
+ ElTypes.push_back(ST->getElementType(i));
return StructValType(ElTypes);
}