nicolas/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove now unused code.

Browse Source 
llvm-svn: 105448
This commit is contained in:
Anders Carlsson
2010-06-04 00:59:37 +00:00
parent 27860db29e
commit fd788405ac
1 changed files with 13 additions and 235 deletions
Download Patch File Download Diff File Expand all files Collapse all files

248
clang/lib/CodeGen/CGVTables.cpp
View File

@@ -98,58 +98,6 @@ private:
/// all the base subobjects of the most derived class.
OverridersMapTy OverridersMap;
/// VisitedVirtualBases - A set of all the visited virtual bases, used to
/// avoid visiting virtual bases more than once.
llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBases;
// FIXME: We might be able to get away with making this a SmallSet.
typedef llvm::SmallSetVector<uint64_t, 2> OffsetSetVectorTy;
/// SubobjectOffsetsMapTy - This map is used for keeping track of all the
/// base subobject offsets that a single class declaration might refer to.
///
/// For example, in:
///
/// struct A { virtual void f(); };
/// struct B1 : A { };
/// struct B2 : A { };
/// struct C : B1, B2 { virtual void f(); };
///
/// when we determine that C::f() overrides A::f(), we need to update the
/// overriders map for both A-in-B1 and A-in-B2 and the subobject offsets map
/// will have the subobject offsets for both A copies.
typedef llvm::DenseMap<const CXXRecordDecl *, OffsetSetVectorTy>
SubobjectOffsetsMapTy;
/// ComputeFinalOverriders - Compute the final overriders for a given base
/// subobject (and all its direct and indirect bases).
void ComputeFinalOverriders(BaseSubobject Base,
bool BaseSubobjectIsVisitedVBase,
uint64_t OffsetInLayoutClass,
SubobjectOffsetsMapTy &Offsets);
/// AddOverriders - Add the final overriders for this base subobject to the
/// map of final overriders.
void AddOverriders(BaseSubobject Base, uint64_t OffsetInLayoutClass,
SubobjectOffsetsMapTy &Offsets);
/// PropagateOverrider - Propagate the NewMD overrider to all the functions
/// that OldMD overrides. For example, if we have:
///
/// struct A { virtual void f(); };
/// struct B : A { virtual void f(); };
/// struct C : B { virtual void f(); };
///
/// and we want to override B::f with C::f, we also need to override A::f with
/// C::f.
void PropagateOverrider(const CXXMethodDecl *OldMD,
uint64_t OverriderOffsetInLayoutClass,
const CXXMethodDecl *NewMD,
SubobjectOffsetsMapTy &Offsets);
static void MergeSubobjectOffsets(const SubobjectOffsetsMapTy &NewOffsets,
SubobjectOffsetsMapTy &Offsets);
/// SubobjectsToOffsetsMapTy - A mapping from a base subobject (represented
/// as a record decl and a subobject number) and its offsets in the most
/// derived class as well as the layout class.
@@ -166,6 +114,13 @@ private:
SubobjectOffsetMapTy &SubobjectLayoutClassOffsets,
SubobjectCountMapTy &SubobjectCounts);
typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy;
/// dump - dump the final overriders for a base subobject, and all its direct
/// and indirect base subobjects.
void dump(llvm::raw_ostream &Out, BaseSubobject Base,
VisitedVirtualBasesSetTy& VisitedVirtualBases);
public:
FinalOverriders(const CXXRecordDecl *MostDerivedClass,
uint64_t MostDerivedClassOffset,
@@ -183,15 +138,10 @@ public:
/// dump - dump the final overriders.
void dump() {
assert(VisitedVirtualBases.empty() &&
"Visited virtual bases aren't empty!");
dump(llvm::errs(), BaseSubobject(MostDerivedClass, 0));
VisitedVirtualBases.clear();
VisitedVirtualBasesSetTy VisitedVirtualBases;
dump(llvm::errs(), BaseSubobject(MostDerivedClass, 0), VisitedVirtualBases);
}
/// dump - dump the final overriders for a base subobject, and all its direct
/// and indirect base subobjects.
void dump(llvm::raw_ostream &Out, BaseSubobject Base);
};
#define DUMP_OVERRIDERS 0
@@ -203,14 +153,7 @@ FinalOverriders::FinalOverriders(const CXXRecordDecl *MostDerivedClass,
MostDerivedClassOffset(MostDerivedClassOffset), LayoutClass(LayoutClass),
Context(MostDerivedClass->getASTContext()),
MostDerivedClassLayout(Context.getASTRecordLayout(MostDerivedClass)) {
#if 0
// Compute the final overriders.
SubobjectOffsetsMapTy Offsets;
ComputeFinalOverriders(BaseSubobject(MostDerivedClass, 0),
/*BaseSubobjectIsVisitedVBase=*/false,
MostDerivedClassOffset, Offsets);
VisitedVirtualBases.clear();
#endif
// Compute base offsets.
SubobjectOffsetMapTy SubobjectOffsets;
SubobjectOffsetMapTy SubobjectLayoutClassOffsets;
@@ -260,46 +203,9 @@ FinalOverriders::FinalOverriders(const CXXRecordDecl *MostDerivedClass,
#if DUMP_OVERRIDERS
// And dump them (for now).
dump();
// Also dump the base offsets (for now).
for (SubobjectOffsetsMapTy::const_iterator I = Offsets.begin(),
E = Offsets.end(); I != E; ++I) {
const OffsetSetVectorTy& OffsetSetVector = I->second;
llvm::errs() << "Base offsets for ";
llvm::errs() << I->first->getQualifiedNameAsString() << '\n';
for (unsigned I = 0, E = OffsetSetVector.size(); I != E; ++I)
llvm::errs() << " " << I << " - " << OffsetSetVector[I] / 8 << '\n';
}
#endif
}
void FinalOverriders::AddOverriders(BaseSubobject Base,
uint64_t OffsetInLayoutClass,
SubobjectOffsetsMapTy &Offsets) {
const CXXRecordDecl *RD = Base.getBase();
for (CXXRecordDecl::method_iterator I = RD->method_begin(),
E = RD->method_end(); I != E; ++I) {
const CXXMethodDecl *MD = *I;
if (!MD->isVirtual())
continue;
// First, propagate the overrider.
PropagateOverrider(MD, OffsetInLayoutClass, MD, Offsets);
// Add the overrider as the final overrider of itself.
OverriderInfo& Overrider =
OverridersMap[std::make_pair(MD, Base.getBaseOffset())];
assert(!Overrider.Method && "Overrider should not exist yet!");
Overrider.Offset = OffsetInLayoutClass;
Overrider.Method = MD;
}
}
static BaseOffset ComputeBaseOffset(ASTContext &Context,
const CXXRecordDecl *DerivedRD,
const CXXBasePath &Path) {
@@ -411,135 +317,6 @@ ComputeReturnAdjustmentBaseOffset(ASTContext &Context,
return ComputeBaseOffset(Context, BaseRD, DerivedRD);
}
void FinalOverriders::PropagateOverrider(const CXXMethodDecl *OldMD,
uint64_t OverriderOffsetInLayoutClass,
const CXXMethodDecl *NewMD,
SubobjectOffsetsMapTy &Offsets) {
for (CXXMethodDecl::method_iterator I = OldMD->begin_overridden_methods(),
E = OldMD->end_overridden_methods(); I != E; ++I) {
const CXXMethodDecl *OverriddenMD = *I;
const CXXRecordDecl *OverriddenRD = OverriddenMD->getParent();
// We want to override OverriddenMD in all subobjects, for example:
//
/// struct A { virtual void f(); };
/// struct B1 : A { };
/// struct B2 : A { };
/// struct C : B1, B2 { virtual void f(); };
///
/// When overriding A::f with C::f we need to do so in both A subobjects.
const OffsetSetVectorTy &OffsetVector = Offsets[OverriddenRD];
// Go through all the subobjects.
for (unsigned I = 0, E = OffsetVector.size(); I != E; ++I) {
uint64_t Offset = OffsetVector[I];
MethodBaseOffsetPairTy MethodAndBaseOffset(OverriddenMD, Offset);
OverriderInfo &Overrider = OverridersMap[MethodAndBaseOffset];
assert(Overrider.Method && "Did not find existing overrider!");
// Set the new overrider.
Overrider.Offset = OverriderOffsetInLayoutClass;
Overrider.Method = NewMD;
// And propagate it further.
PropagateOverrider(OverriddenMD, OverriderOffsetInLayoutClass, NewMD,
Offsets);
}
}
}
void
FinalOverriders::MergeSubobjectOffsets(const SubobjectOffsetsMapTy &NewOffsets,
SubobjectOffsetsMapTy &Offsets) {
// Iterate over the new offsets.
for (SubobjectOffsetsMapTy::const_iterator I = NewOffsets.begin(),
E = NewOffsets.end(); I != E; ++I) {
const CXXRecordDecl *NewRD = I->first;
const OffsetSetVectorTy& NewOffsetVector = I->second;
OffsetSetVectorTy &OffsetVector = Offsets[NewRD];
// Merge the new offsets set vector into the old.
OffsetVector.insert(NewOffsetVector.begin(), NewOffsetVector.end());
}
}
void FinalOverriders::ComputeFinalOverriders(BaseSubobject Base,
bool BaseSubobjectIsVisitedVBase,
uint64_t OffsetInLayoutClass,
SubobjectOffsetsMapTy &Offsets) {
const CXXRecordDecl *RD = Base.getBase();
const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
SubobjectOffsetsMapTy NewOffsets;
for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
E = RD->bases_end(); I != E; ++I) {
const CXXRecordDecl *BaseDecl =
cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
// Ignore bases that don't have any virtual member functions.
if (!BaseDecl->isPolymorphic())
continue;
bool IsVisitedVirtualBase = BaseSubobjectIsVisitedVBase;
uint64_t BaseOffset;
uint64_t BaseOffsetInLayoutClass;
if (I->isVirtual()) {
if (!VisitedVirtualBases.insert(BaseDecl))
IsVisitedVirtualBase = true;
BaseOffset = MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
const ASTRecordLayout &LayoutClassLayout =
Context.getASTRecordLayout(LayoutClass);
BaseOffsetInLayoutClass =
LayoutClassLayout.getVBaseClassOffset(BaseDecl);
} else {
BaseOffset = Layout.getBaseClassOffset(BaseDecl) + Base.getBaseOffset();
BaseOffsetInLayoutClass = Layout.getBaseClassOffset(BaseDecl) +
OffsetInLayoutClass;
}
// Compute the final overriders for this base.
// We always want to compute the final overriders, even if the base is a
// visited virtual base. Consider:
//
// struct A {
// virtual void f();
// virtual void g();
// };
//
// struct B : virtual A {
// void f();
// };
//
// struct C : virtual A {
// void g ();
// };
//
// struct D : B, C { };
//
// Here, we still want to compute the overriders for A as a base of C,
// because otherwise we'll miss that C::g overrides A::f.
ComputeFinalOverriders(BaseSubobject(BaseDecl, BaseOffset),
IsVisitedVirtualBase, BaseOffsetInLayoutClass,
NewOffsets);
}
/// Now add the overriders for this particular subobject.
/// (We don't want to do this more than once for a virtual base).
if (!BaseSubobjectIsVisitedVBase)
AddOverriders(Base, OffsetInLayoutClass, NewOffsets);
// And merge the newly discovered subobject offsets.
MergeSubobjectOffsets(NewOffsets, Offsets);
/// Finally, add the offset for our own subobject.
Offsets[RD].insert(Base.getBaseOffset());
}
void
FinalOverriders::ComputeBaseOffsets(BaseSubobject Base, bool IsVirtual,
uint64_t OffsetInLayoutClass,
@@ -596,7 +373,8 @@ FinalOverriders::ComputeBaseOffsets(BaseSubobject Base, bool IsVirtual,
}
}
void FinalOverriders::dump(llvm::raw_ostream &Out, BaseSubobject Base) {
void FinalOverriders::dump(llvm::raw_ostream &Out, BaseSubobject Base,
VisitedVirtualBasesSetTy &VisitedVirtualBases) {
const CXXRecordDecl *RD = Base.getBase();
const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
@@ -622,7 +400,7 @@ void FinalOverriders::dump(llvm::raw_ostream &Out, BaseSubobject Base) {
Base.getBaseOffset();
}
dump(Out, BaseSubobject(BaseDecl, BaseOffset));
dump(Out, BaseSubobject(BaseDecl, BaseOffset), VisitedVirtualBases);
}
Out << "Final overriders for (" << RD->getQualifiedNameAsString() << ", ";