//===----------------------------------------------------------------------===//
#include "ValueEnumerator.h"
+#include "llvm/DerivedTypes.h"
#include "llvm/Module.h"
#include "llvm/TypeSymbolTable.h"
#include "llvm/ValueSymbolTable.h"
for (Type::subtype_iterator I = Ty->subtype_begin(), E = Ty->subtype_end();
I != E; ++I)
EnumerateType(*I);
+
+ // If this is a function type, enumerate the param attrs.
+ if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty))
+ EnumerateParamAttrs(FTy->getParamAttrs());
}
+void ValueEnumerator::EnumerateParamAttrs(const ParamAttrsList *PAL) {
+ if (PAL == 0) return; // null is always 0.
+ // Do a lookup.
+ unsigned &Entry = ParamAttrMap[PAL];
+ if (Entry == 0) {
+ // Never saw this before, add it.
+ ParamAttrs.push_back(PAL);
+ Entry = ParamAttrs.size();
+ }
+}
+
+
/// PurgeAggregateValues - If there are any aggregate values at the end of the
/// value list, remove them and return the count of the remaining values. If
/// there are none, return -1.
class BasicBlock;
class Function;
class Module;
+class ParamAttrsList;
class TypeSymbolTable;
class ValueSymbolTable;
ValueMapType ValueMap;
ValueList Values;
+ typedef DenseMap<const ParamAttrsList*, unsigned> ParamAttrMapType;
+ ParamAttrMapType ParamAttrMap;
+ std::vector<const ParamAttrsList*> ParamAttrs;
+
/// BasicBlocks - This contains all the basic blocks for the currently
/// incorporated function. Their reverse mapping is stored in ValueMap.
std::vector<const BasicBlock*> BasicBlocks;
assert(I != TypeMap.end() && "Type not in ValueEnumerator!");
return I->second-1;
}
+
+ unsigned getParamAttrID(const ParamAttrsList *PAL) const {
+ if (PAL == 0) return 0; // Null maps to zero.
+ ParamAttrMapType::const_iterator I = ParamAttrMap.find(PAL);
+ assert(I != ParamAttrMap.end() && "ParamAttr not in ValueEnumerator!");
+ return I->second;
+ }
/// getFunctionConstantRange - Return the range of values that corresponds to
/// function-local constants.
const std::vector<const BasicBlock*> &getBasicBlocks() const {
return BasicBlocks;
}
+ const std::vector<const ParamAttrsList*> getParamAttrs() const {
+ return ParamAttrs;
+ }
/// PurgeAggregateValues - If there are any aggregate values at the end of the
/// value list, remove them and return the count of the remaining values. If
private:
void EnumerateValue(const Value *V);
void EnumerateType(const Type *T);
+ void EnumerateParamAttrs(const ParamAttrsList *PAL);
void EnumerateTypeSymbolTable(const TypeSymbolTable &ST);
void EnumerateValueSymbolTable(const ValueSymbolTable &ST);