lib/AST/ExprConstant.cpp

270     SmallVector<PathEntry, 8> Entries;
288         Entries.insert(Entries.end(), VEntries.begin(), VEntries.end());
307       assert(NewLength <= Entries.size() && "not a truncation");
309       if (NewLength == Entries.size())
311       Entries.resize(NewLength);
316           Ctx, Base, Entries, MostDerivedArraySize, MostDerivedType, IsArray,
324       Entries.clear();
331       return Entries.size() == 1 && FirstEntryIsAnUnsizedArray;
347           Entries[MostDerivedPathLength - 1].getAsArrayIndex() ==
363       bool IsArray = MostDerivedPathLength == Entries.size() &&
365       uint64_t ArrayIndex = IsArray ? Entries.back().getAsArrayIndex()
385       return MostDerivedPathLength == Entries.size()
387                  : Ctx.getRecordType(getAsBaseClass(Entries.back()));
392       Entries.push_back(PathEntry::ArrayIndex(0));
398       MostDerivedPathLength = Entries.size();
403       Entries.push_back(PathEntry::ArrayIndex(0));
411       MostDerivedPathLength = Entries.size();
416       Entries.push_back(APValue::BaseOrMemberType(D, Virtual));
423         MostDerivedPathLength = Entries.size();
428       Entries.push_back(PathEntry::ArrayIndex(Imag));
435       MostDerivedPathLength = Entries.size();
449         Entries.back() = PathEntry::ArrayIndex(
450             Entries.back().getAsArrayIndex() + TruncatedN);
457       bool IsArray = MostDerivedPathLength == Entries.size() &&
459       uint64_t ArrayIndex = IsArray ? Entries.back().getAsArrayIndex()
480         Entries.back() = PathEntry::ArrayIndex(ArrayIndex);
1427   if (MostDerivedPathLength == Entries.size() && MostDerivedIsArrayElement)
1571         V = APValue(Base, Offset, Designator.Entries,
1663       if (!Designator.Entries.empty()) {
2153           << IsReferenceType << !Designator.Entries.empty() << InvalidBaseKind
2175         << IsReferenceType << !Designator.Entries.empty()
2203         << IsReferenceType << !Designator.Entries.empty();
2272       << !Designator.Entries.empty() << !!BaseVD << BaseVD;
3029   if (TruncatedElements == D.Entries.size())
3038   for (unsigned I = TruncatedElements, N = D.Entries.size(); I != N; ++I) {
3041     const CXXRecordDecl *Base = getAsBaseClass(D.Entries[I]);
3042     if (isVirtualBaseClass(D.Entries[I]))
3048   D.Entries.resize(TruncatedElements);
3616   for (unsigned I = 0, N = Sub.Entries.size(); /**/; ++I) {
3633             Obj.Base, llvm::makeArrayRef(Sub.Entries.begin(),
3634                                          Sub.Entries.begin() + I)) !=
3699       uint64_t Index = Sub.Entries[I].getAsArrayIndex();
3722       uint64_t Index = Sub.Entries[I].getAsArrayIndex();
3744     } else if (const FieldDecl *Field = getAsField(Sub.Entries[I])) {
3783       const CXXRecordDecl *Base = getAsBaseClass(Sub.Entries[I]);
3890   unsigned I = 0, N = std::min(A.Entries.size(), B.Entries.size());
3895       if (A.Entries[I].getAsArrayIndex() != B.Entries[I].getAsArrayIndex()) {
3904       if (A.Entries[I].getAsBaseOrMember() !=
3905           B.Entries[I].getAsBaseOrMember()) {
3909       if (const FieldDecl *FD = getAsField(A.Entries[I]))
3926   if (A.Entries.size() != B.Entries.size())
3930   if (IsArray && A.MostDerivedPathLength != A.Entries.size())
3939   return CommonLength >= A.Entries.size() - IsArray;
4238       assert(LVal.Designator.Entries.size() <= 1 &&
4240       if (LVal.Designator.Entries.empty()) {
4254       uint64_t CharIndex = LVal.Designator.Entries[0].getAsArrayIndex();
4617         LV.Designator.Entries.size()) {
4622         LV.Designator.Entries.size() - MemPtr.Path.size();
4625           LV.Designator.Entries[PathLengthToMember + I]);
4639     LV.Designator.Entries.reserve(LV.Designator.Entries.size() +
4708   if (D.MostDerivedPathLength + E->path_size() > D.Entries.size()) {
4716   unsigned NewEntriesSize = D.Entries.size() - E->path_size();
4722     FinalType = getAsBaseClass(D.Entries[NewEntriesSize - 1]);
5574       Designator.Entries.size() && "invalid path length");
5577              : getAsBaseClass(Designator.Entries[PathLength - 1]);
5606   ArrayRef<APValue::LValuePathEntry> Path = This.Designator.Entries;
5651   for (/**/; PathLength <= This.Designator.Entries.size(); ++PathLength) {
5676          CovariantPathLength != This.Designator.Entries.size();
5804   for (int PathLength = Ptr.Designator.Entries.size();
5898   unsigned PathLength = LHS.Designator.Entries.size();
5922                                 LHS.Designator.Entries[PathLength]
5949                                   LHS.Designator.Entries[PathLength]
5975     bool DuringInit = Info.isEvaluatingCtorDtor(LHS.Base, D.Entries) ==
6144       ObjectUnderConstruction{This.getLValueBase(), This.Designator.Entries},
6453       ObjectUnderConstruction{This.getLValueBase(), This.Designator.Entries});
6685     Subobject = Pointer.Designator.Entries.size() != 1 ||
6686                 Pointer.Designator.Entries[0].getAsArrayIndex() != 0;
9784       ObjectUnderConstruction{This.getLValueBase(), This.Designator.Entries},
11240   for (unsigned E = LVal.Designator.Entries.size(); I != E; ++I) {
11241     const auto &Entry = LVal.Designator.Entries[I];
11279   if (!LVal.Designator.Entries.empty())
11307          Designator.Entries.size() == Designator.MostDerivedPathLength &&
11394       Designator.Entries.size() == Designator.MostDerivedPathLength) {
11396     uint64_t ArrayIndex = Designator.Entries.back().getAsArrayIndex();
12698       if (!WasArrayIndex && Mismatch < LHSDesignator.Entries.size() &&
12699           Mismatch < RHSDesignator.Entries.size()) {
12700         const FieldDecl *LF = getAsField(LHSDesignator.Entries[Mismatch]);
12701         const FieldDecl *RF = getAsField(RHSDesignator.Entries[Mismatch]);
12706               << getAsBaseClass(LHSDesignator.Entries[Mismatch])
12710               << getAsBaseClass(RHSDesignator.Entries[Mismatch])
14444   if (!E->isArrayForm() && Pointer.Designator.Entries.size() != 0 &&