typedef std::map<const TypeClass*, MapIterator> AbstractTypeMapTy;
AbstractTypeMapTy AbstractTypeMap;
+
+ friend void Constant::clearAllValueMaps();
+ private:
+ void clear(std::vector<Constant *> &Constants) {
+ for(MapIterator I = Map.begin(); I != Map.end(); ++I)
+ Constants.push_back(I->second);
+ Map.clear();
+ AbstractTypeMap.clear();
+ }
+
public:
// getOrCreate - Return the specified constant from the map, creating it if
// necessary.
return Instruction::getOpcodeName(getOpcode());
}
+/// clearAllValueMaps - This method frees all internal memory used by the
+/// constant subsystem, which can be used in environments where this memory
+/// is otherwise reported as a leak.
+void Constant::clearAllValueMaps() {
+ std::vector<Constant *> Constants;
+
+ DoubleConstants.clear(Constants);
+ FloatConstants.clear(Constants);
+ SIntConstants.clear(Constants);
+ UIntConstants.clear(Constants);
+ AggZeroConstants.clear(Constants);
+ ArrayConstants.clear(Constants);
+ StructConstants.clear(Constants);
+ PackedConstants.clear(Constants);
+ NullPtrConstants.clear(Constants);
+ UndefValueConstants.clear(Constants);
+ ExprConstants.clear(Constants);
+
+ for (std::vector<Constant *>::iterator I = Constants.begin(),
+ E = Constants.end(); I != E; ++I)
+ (*I)->dropAllReferences();
+ for (std::vector<Constant *>::iterator I = Constants.begin(),
+ E = Constants.end(); I != E; ++I)
+ (*I)->destroyConstantImpl();
+ Constants.clear();
+}
/// this map.
///
std::multimap<unsigned, PATypeHolder> TypesByHash;
+
+ friend void Type::clearAllTypeMaps();
+
+private:
+ void clear(std::vector<Type *> &DerivedTypes) {
+ for (typename std::map<ValType, PATypeHolder>::iterator I = Map.begin(),
+ E = Map.end(); I != E; ++I)
+ DerivedTypes.push_back(I->second.get());
+ TypesByHash.clear();
+ Map.clear();
+ }
public:
typedef typename std::map<ValType, PATypeHolder>::iterator iterator;
~TypeMap() { print("ON EXIT"); }
}
}
+/// clearAllTypeMaps - This method frees all internal memory used by the
+/// type subsystem, which can be used in environments where this memory is
+/// otherwise reported as a leak.
+void Type::clearAllTypeMaps() {
+ std::vector<Type *> DerivedTypes;
+
+ FunctionTypes.clear(DerivedTypes);
+ PointerTypes.clear(DerivedTypes);
+ StructTypes.clear(DerivedTypes);
+ ArrayTypes.clear(DerivedTypes);
+ PackedTypes.clear(DerivedTypes);
+
+ for(std::vector<Type *>::iterator I = DerivedTypes.begin(),
+ E = DerivedTypes.end(); I != E; ++I)
+ (*I)->ContainedTys.clear();
+ for(std::vector<Type *>::iterator I = DerivedTypes.begin(),
+ E = DerivedTypes.end(); I != E; ++I)
+ delete *I;
+ DerivedTypes.clear();
+}
+
// vim: sw=2