Summary: This should make the code more readable, especially all the map declarations.
Reviewers: tejohnson
Subscribers: llvm-commits
Differential Revision: http://reviews.llvm.org/D18721
From: Mehdi Amini <mehdi.amini@apple.com>
llvm-svn: 265215
/// used as the key for a global lookup (e.g. profile or ThinLTO).
std::string getGlobalIdentifier();
+ /// Declare a type to represent a global unique identifier for a global value.
+ /// This is a 64 bits hash that is used by PGO and ThinLTO to have a compact
+ /// unique way to identify a symbol.
+ using GUID = uint64_t;
+
/// Return a 64-bit global unique ID constructed from global value name
/// (i.e. returned by getGlobalIdentifier()).
- static uint64_t getGUID(StringRef GlobalName) { return MD5Hash(GlobalName); }
+ static GUID getGUID(StringRef GlobalName) { return MD5Hash(GlobalName); }
/// Return a 64-bit global unique ID constructed from global value name
/// (i.e. returned by getGlobalIdentifier()).
- uint64_t getGUID() { return getGUID(getGlobalIdentifier()); }
+ GUID getGUID() { return getGUID(getGlobalIdentifier()); }
/// @name Materialization
/// Materialization is used to construct functions only as they're needed.
/// (either by the initializer of a global variable, or referenced
/// from within a function). This does not include functions called, which
/// are listed in the derived FunctionSummary object.
- std::vector<uint64_t> RefEdgeList;
+ std::vector<GlobalValue::GUID> RefEdgeList;
protected:
/// GlobalValueSummary constructor.
/// Record a reference from this global value to the global value identified
/// by \p RefGUID.
- void addRefEdge(uint64_t RefGUID) { RefEdgeList.push_back(RefGUID); }
+ void addRefEdge(GlobalValue::GUID RefGUID) { RefEdgeList.push_back(RefGUID); }
/// Record a reference from this global value to each global value identified
/// in \p RefEdges.
}
/// Return the list of GUIDs referenced by this global value definition.
- std::vector<uint64_t> &refs() { return RefEdgeList; }
- const std::vector<uint64_t> &refs() const { return RefEdgeList; }
+ std::vector<GlobalValue::GUID> &refs() { return RefEdgeList; }
+ const std::vector<GlobalValue::GUID> &refs() const { return RefEdgeList; }
};
/// \brief Function summary information to aid decisions and implementation of
class FunctionSummary : public GlobalValueSummary {
public:
/// <CalleeGUID, CalleeInfo> call edge pair.
- typedef std::pair<uint64_t, CalleeInfo> EdgeTy;
+ typedef std::pair<GlobalValue::GUID, CalleeInfo> EdgeTy;
private:
/// Number of instructions (ignoring debug instructions, e.g.) computed
/// Record a call graph edge from this function to the function identified
/// by \p CalleeGUID, with \p CalleeInfo including the cumulative profile
/// count (across all calls from this function) or 0 if no PGO.
- void addCallGraphEdge(uint64_t CalleeGUID, CalleeInfo Info) {
+ void addCallGraphEdge(GlobalValue::GUID CalleeGUID, CalleeInfo Info) {
CallGraphEdgeList.push_back(std::make_pair(CalleeGUID, Info));
}
/// less overhead, as the value type is not very small and the size
/// of the map is unknown, resulting in inefficiencies due to repeated
/// insertions and resizing.
-typedef std::map<uint64_t, GlobalValueInfoList> GlobalValueInfoMapTy;
+typedef std::map<GlobalValue::GUID, GlobalValueInfoList> GlobalValueInfoMapTy;
/// Type used for iterating through the global value info map.
typedef GlobalValueInfoMapTy::const_iterator const_globalvalueinfo_iterator;
/// Get the list of global value info objects for a given value GUID.
const const_globalvalueinfo_iterator
- findGlobalValueInfoList(uint64_t ValueGUID) const {
+ findGlobalValueInfoList(GlobalValue::GUID ValueGUID) const {
return GlobalValueMap.find(ValueGUID);
}
}
/// Add a global value info for a value of the given GUID.
- void addGlobalValueInfo(uint64_t ValueGUID,
+ void addGlobalValueInfo(GlobalValue::GUID ValueGUID,
std::unique_ptr<GlobalValueInfo> Info) {
GlobalValueMap[ValueGUID].push_back(std::move(Info));
}
#define LLVM_FUNCTIONIMPORT_H
#include "llvm/ADT/StringMap.h"
+#include "llvm/IR/GlobalValue.h"
#include <functional>
#include <map>
/// containing all the functions to import for a source module.
/// The keys is the GUID identifying a function to import, and the value
/// is the threshold applied when deciding to import it.
- typedef std::map<uint64_t, unsigned> FunctionsToImportTy;
+ typedef std::map<GlobalValue::GUID, unsigned> FunctionsToImportTy;
/// The map contains an entry for every module to import from, the key being
/// the module identifier to pass to the ModuleLoader. The value is the set of
typedef StringMap<FunctionsToImportTy> ImportMapTy;
/// The set contains an entry for every global value the module exports.
- typedef std::unordered_set<uint64_t> ExportSetTy;
+ typedef std::unordered_set<GlobalValue::GUID> ExportSetTy;
/// Create a Function Importer.
FunctionImporter(
// call graph edges read from the function summary from referencing
// callees by their ValueId to using the GUID instead, which is how
// they are recorded in the summary index being built.
- DenseMap<unsigned, uint64_t> ValueIdToCallGraphGUIDMap;
+ DenseMap<unsigned, GlobalValue::GUID> ValueIdToCallGraphGUIDMap;
/// Map to save the association between summary offset in the VST to the
/// GlobalValueInfo object created when parsing it. Used to access the
std::error_code initStream(std::unique_ptr<DataStreamer> Streamer);
std::error_code initStreamFromBuffer();
std::error_code initLazyStream(std::unique_ptr<DataStreamer> Streamer);
- uint64_t getGUIDFromValueId(unsigned ValueId);
+ GlobalValue::GUID getGUIDFromValueId(unsigned ValueId);
GlobalValueInfo *getInfoFromSummaryOffset(uint64_t Offset);
};
} // end anonymous namespace
void ModuleSummaryIndexBitcodeReader::releaseBuffer() { Buffer.release(); }
-uint64_t ModuleSummaryIndexBitcodeReader::getGUIDFromValueId(unsigned ValueId) {
+GlobalValue::GUID
+ModuleSummaryIndexBitcodeReader::getGUIDFromValueId(unsigned ValueId) {
auto VGI = ValueIdToCallGraphGUIDMap.find(ValueId);
assert(VGI != ValueIdToCallGraphGUIDMap.end());
return VGI->second;
// VST_CODE_COMBINED_GVDEFENTRY: [valueid, offset, guid]
unsigned ValueID = Record[0];
uint64_t GlobalValSummaryOffset = Record[1];
- uint64_t GlobalValGUID = Record[2];
+ GlobalValue::GUID GlobalValGUID = Record[2];
std::unique_ptr<GlobalValueInfo> GlobalValInfo =
llvm::make_unique<GlobalValueInfo>(GlobalValSummaryOffset);
SummaryOffsetToInfoMap[GlobalValSummaryOffset] = GlobalValInfo.get();
case bitc::VST_CODE_COMBINED_ENTRY: {
// VST_CODE_COMBINED_ENTRY: [valueid, refguid]
unsigned ValueID = Record[0];
- uint64_t RefGUID = Record[1];
+ GlobalValue::GUID RefGUID = Record[1];
ValueIdToCallGraphGUIDMap[ValueID] = RefGUID;
break;
}
"Record size inconsistent with number of references");
for (unsigned I = 4, E = CallGraphEdgeStartIndex; I != E; ++I) {
unsigned RefValueId = Record[I];
- uint64_t RefGUID = getGUIDFromValueId(RefValueId);
+ GlobalValue::GUID RefGUID = getGUIDFromValueId(RefValueId);
FS->addRefEdge(RefGUID);
}
bool HasProfile = (BitCode == bitc::FS_PERMODULE_PROFILE);
unsigned CalleeValueId = Record[I];
unsigned CallsiteCount = Record[++I];
uint64_t ProfileCount = HasProfile ? Record[++I] : 0;
- uint64_t CalleeGUID = getGUIDFromValueId(CalleeValueId);
+ GlobalValue::GUID CalleeGUID = getGUIDFromValueId(CalleeValueId);
FS->addCallGraphEdge(CalleeGUID,
CalleeInfo(CallsiteCount, ProfileCount));
}
- uint64_t GUID = getGUIDFromValueId(ValueID);
+ GlobalValue::GUID GUID = getGUIDFromValueId(ValueID);
auto InfoList = TheIndex->findGlobalValueInfoList(GUID);
assert(InfoList != TheIndex->end() &&
"Expected VST parse to create GlobalValueInfo entry");
TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0)->first());
for (unsigned I = 2, E = Record.size(); I != E; ++I) {
unsigned RefValueId = Record[I];
- uint64_t RefGUID = getGUIDFromValueId(RefValueId);
+ GlobalValue::GUID RefGUID = getGUIDFromValueId(RefValueId);
FS->addRefEdge(RefGUID);
}
- uint64_t GUID = getGUIDFromValueId(ValueID);
+ GlobalValue::GUID GUID = getGUIDFromValueId(ValueID);
auto InfoList = TheIndex->findGlobalValueInfoList(GUID);
assert(InfoList != TheIndex->end() &&
"Expected VST parse to create GlobalValueInfo entry");
"Record size inconsistent with number of references");
for (unsigned I = 4, E = CallGraphEdgeStartIndex; I != E; ++I) {
unsigned RefValueId = Record[I];
- uint64_t RefGUID = getGUIDFromValueId(RefValueId);
+ GlobalValue::GUID RefGUID = getGUIDFromValueId(RefValueId);
FS->addRefEdge(RefGUID);
}
bool HasProfile = (BitCode == bitc::FS_COMBINED_PROFILE);
unsigned CalleeValueId = Record[I];
unsigned CallsiteCount = Record[++I];
uint64_t ProfileCount = HasProfile ? Record[++I] : 0;
- uint64_t CalleeGUID = getGUIDFromValueId(CalleeValueId);
+ GlobalValue::GUID CalleeGUID = getGUIDFromValueId(CalleeValueId);
FS->addCallGraphEdge(CalleeGUID,
CalleeInfo(CallsiteCount, ProfileCount));
}
FS->setModulePath(ModuleIdMap[ModuleId]);
for (unsigned I = 2, E = Record.size(); I != E; ++I) {
unsigned RefValueId = Record[I];
- uint64_t RefGUID = getGUIDFromValueId(RefValueId);
+ GlobalValue::GUID RefGUID = getGUIDFromValueId(RefValueId);
FS->addRefEdge(RefGUID);
}
auto *Info = getInfoFromSummaryOffset(CurRecordBit);
/// Emit function names and summary offsets for the combined index
/// used by ThinLTO.
-static void
-WriteCombinedValueSymbolTable(const ModuleSummaryIndex &Index,
- BitstreamWriter &Stream,
- std::map<uint64_t, unsigned> &GUIDToValueIdMap,
- uint64_t VSTOffsetPlaceholder) {
+static void WriteCombinedValueSymbolTable(
+ const ModuleSummaryIndex &Index, BitstreamWriter &Stream,
+ std::map<GlobalValue::GUID, unsigned> &GUIDToValueIdMap,
+ uint64_t VSTOffsetPlaceholder) {
assert(VSTOffsetPlaceholder > 0 && "Expected non-zero VSTOffsetPlaceholder");
// Get the offset of the VST we are writing, and backpatch it into
// the VST forward declaration record.
SmallVector<uint64_t, 64> NameVals;
for (const auto &FII : Index) {
- uint64_t FuncGUID = FII.first;
+ GlobalValue::GUID FuncGUID = FII.first;
const auto &VMI = GUIDToValueIdMap.find(FuncGUID);
assert(VMI != GUIDToValueIdMap.end());
/// Emit the combined summary section into the combined index file.
static void WriteCombinedGlobalValueSummary(
const ModuleSummaryIndex &I, BitstreamWriter &Stream,
- std::map<uint64_t, unsigned> &GUIDToValueIdMap, unsigned GlobalValueId) {
+ std::map<GlobalValue::GUID, unsigned> &GUIDToValueIdMap,
+ unsigned GlobalValueId) {
Stream.EnterSubblock(bitc::GLOBALVAL_SUMMARY_BLOCK_ID, 3);
// Abbrev for FS_COMBINED.
// in writing out the call graph edges. Save the mapping from GUID
// to the new global value id to use when writing those edges, which
// are currently saved in the index in terms of GUID.
- std::map<uint64_t, unsigned> GUIDToValueIdMap;
+ std::map<GlobalValue::GUID, unsigned> GUIDToValueIdMap;
unsigned GlobalValueId = 0;
for (auto &II : Index)
GUIDToValueIdMap[II.first] = ++GlobalValueId;
StringRef ModPath;
for (auto &OtherGlobalValInfoLists : *Other) {
- uint64_t ValueGUID = OtherGlobalValInfoLists.first;
+ GlobalValue::GUID ValueGUID = OtherGlobalValInfoLists.first;
GlobalValueInfoList &List = OtherGlobalValInfoLists.second;
// Assert that the value info list only has one entry, since we shouldn't
/// Return the summary for the function \p GUID that fits the \p Threshold, or
/// null if there's no match.
-static const FunctionSummary *selectCallee(uint64_t GUID, unsigned Threshold,
+static const FunctionSummary *selectCallee(GlobalValue::GUID GUID,
+ unsigned Threshold,
const ModuleSummaryIndex &Index) {
auto CalleeInfoList = Index.findGlobalValueInfoList(GUID);
if (CalleeInfoList == Index.end()) {
/// Return true if the global \p GUID is exported by module \p ExportModulePath.
static bool isGlobalExported(const ModuleSummaryIndex &Index,
- StringRef ExportModulePath, uint64_t GUID) {
+ StringRef ExportModulePath,
+ GlobalValue::GUID GUID) {
auto CalleeInfoList = Index.findGlobalValueInfoList(GUID);
if (CalleeInfoList == Index.end())
// This global does not have a summary, it is not part of the ThinLTO
static void computeImportForFunction(
StringRef ModulePath, const FunctionSummary &Summary,
const ModuleSummaryIndex &Index, unsigned Threshold,
- const std::map<uint64_t, FunctionSummary *> &DefinedFunctions,
+ const std::map<GlobalValue::GUID, FunctionSummary *> &DefinedFunctions,
SmallVectorImpl<EdgeInfo> &Worklist,
FunctionImporter::ImportMapTy &ImportsForModule,
StringMap<FunctionImporter::ExportSetTy> &ExportLists) {
/// another module (that may require promotion).
static void ComputeImportForModule(
StringRef ModulePath,
- const std::map<uint64_t, FunctionSummary *> &DefinedFunctions,
+ const std::map<GlobalValue::GUID, FunctionSummary *> &DefinedFunctions,
const ModuleSummaryIndex &Index,
FunctionImporter::ImportMapTy &ImportsForModule,
StringMap<FunctionImporter::ExportSetTy> &ExportLists) {
// Collect for each module the list of function it defines.
// GUID -> Summary
- StringMap<std::map<uint64_t, FunctionSummary *>> Module2FunctionInfoMap(
- ModuleCount);
+ StringMap<std::map<GlobalValue::GUID, FunctionSummary *>>
+ Module2FunctionInfoMap(ModuleCount);
for (auto &GlobalList : Index) {
auto GUID = GlobalList.first;